Merge branch 'topic/ca0106' into to-push
[linux-2.6] / drivers / scsi / arm / powertec.c
1 /*
2  *  linux/drivers/acorn/scsi/powertec.c
3  *
4  *  Copyright (C) 1997-2005 Russell King
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  */
10 #include <linux/module.h>
11 #include <linux/blkdev.h>
12 #include <linux/kernel.h>
13 #include <linux/string.h>
14 #include <linux/ioport.h>
15 #include <linux/proc_fs.h>
16 #include <linux/delay.h>
17 #include <linux/interrupt.h>
18 #include <linux/init.h>
19 #include <linux/dma-mapping.h>
20
21 #include <asm/dma.h>
22 #include <asm/ecard.h>
23 #include <asm/io.h>
24 #include <asm/pgtable.h>
25
26 #include "../scsi.h"
27 #include <scsi/scsi_host.h>
28 #include "fas216.h"
29 #include "scsi.h"
30
31 #include <scsi/scsicam.h>
32
33 #define POWERTEC_FAS216_OFFSET  0x3000
34 #define POWERTEC_FAS216_SHIFT   6
35
36 #define POWERTEC_INTR_STATUS    0x2000
37 #define POWERTEC_INTR_BIT       0x80
38
39 #define POWERTEC_RESET_CONTROL  0x1018
40 #define POWERTEC_RESET_BIT      1
41
42 #define POWERTEC_TERM_CONTROL   0x2018
43 #define POWERTEC_TERM_ENABLE    1
44
45 #define POWERTEC_INTR_CONTROL   0x101c
46 #define POWERTEC_INTR_ENABLE    1
47 #define POWERTEC_INTR_DISABLE   0
48
49 #define VERSION "1.10 (19/01/2003 2.5.59)"
50
51 /*
52  * Use term=0,1,0,0,0 to turn terminators on/off.
53  * One entry per slot.
54  */
55 static int term[MAX_ECARDS] = { 1, 1, 1, 1, 1, 1, 1, 1 };
56
57 #define NR_SG   256
58
59 struct powertec_info {
60         FAS216_Info             info;
61         struct expansion_card   *ec;
62         void __iomem            *base;
63         unsigned int            term_ctl;
64         struct scatterlist      sg[NR_SG];
65 };
66
67 /* Prototype: void powertecscsi_irqenable(ec, irqnr)
68  * Purpose  : Enable interrupts on Powertec SCSI card
69  * Params   : ec    - expansion card structure
70  *          : irqnr - interrupt number
71  */
72 static void
73 powertecscsi_irqenable(struct expansion_card *ec, int irqnr)
74 {
75         struct powertec_info *info = ec->irq_data;
76         writeb(POWERTEC_INTR_ENABLE, info->base + POWERTEC_INTR_CONTROL);
77 }
78
79 /* Prototype: void powertecscsi_irqdisable(ec, irqnr)
80  * Purpose  : Disable interrupts on Powertec SCSI card
81  * Params   : ec    - expansion card structure
82  *          : irqnr - interrupt number
83  */
84 static void
85 powertecscsi_irqdisable(struct expansion_card *ec, int irqnr)
86 {
87         struct powertec_info *info = ec->irq_data;
88         writeb(POWERTEC_INTR_DISABLE, info->base + POWERTEC_INTR_CONTROL);
89 }
90
91 static const expansioncard_ops_t powertecscsi_ops = {
92         .irqenable      = powertecscsi_irqenable,
93         .irqdisable     = powertecscsi_irqdisable,
94 };
95
96 /* Prototype: void powertecscsi_terminator_ctl(host, on_off)
97  * Purpose  : Turn the Powertec SCSI terminators on or off
98  * Params   : host   - card to turn on/off
99  *          : on_off - !0 to turn on, 0 to turn off
100  */
101 static void
102 powertecscsi_terminator_ctl(struct Scsi_Host *host, int on_off)
103 {
104         struct powertec_info *info = (struct powertec_info *)host->hostdata;
105
106         info->term_ctl = on_off ? POWERTEC_TERM_ENABLE : 0;
107         writeb(info->term_ctl, info->base + POWERTEC_TERM_CONTROL);
108 }
109
110 /* Prototype: void powertecscsi_intr(irq, *dev_id, *regs)
111  * Purpose  : handle interrupts from Powertec SCSI card
112  * Params   : irq    - interrupt number
113  *            dev_id - user-defined (Scsi_Host structure)
114  */
115 static irqreturn_t powertecscsi_intr(int irq, void *dev_id)
116 {
117         struct powertec_info *info = dev_id;
118
119         return fas216_intr(&info->info);
120 }
121
122 /* Prototype: fasdmatype_t powertecscsi_dma_setup(host, SCpnt, direction, min_type)
123  * Purpose  : initialises DMA/PIO
124  * Params   : host      - host
125  *            SCpnt     - command
126  *            direction - DMA on to/off of card
127  *            min_type  - minimum DMA support that we must have for this transfer
128  * Returns  : type of transfer to be performed
129  */
130 static fasdmatype_t
131 powertecscsi_dma_setup(struct Scsi_Host *host, struct scsi_pointer *SCp,
132                        fasdmadir_t direction, fasdmatype_t min_type)
133 {
134         struct powertec_info *info = (struct powertec_info *)host->hostdata;
135         struct device *dev = scsi_get_device(host);
136         int dmach = info->info.scsi.dma;
137
138         if (info->info.ifcfg.capabilities & FASCAP_DMA &&
139             min_type == fasdma_real_all) {
140                 int bufs, map_dir, dma_dir;
141
142                 bufs = copy_SCp_to_sg(&info->sg[0], SCp, NR_SG);
143
144                 if (direction == DMA_OUT)
145                         map_dir = DMA_TO_DEVICE,
146                         dma_dir = DMA_MODE_WRITE;
147                 else
148                         map_dir = DMA_FROM_DEVICE,
149                         dma_dir = DMA_MODE_READ;
150
151                 dma_map_sg(dev, info->sg, bufs, map_dir);
152
153                 disable_dma(dmach);
154                 set_dma_sg(dmach, info->sg, bufs);
155                 set_dma_mode(dmach, dma_dir);
156                 enable_dma(dmach);
157                 return fasdma_real_all;
158         }
159
160         /*
161          * If we're not doing DMA,
162          *  we'll do slow PIO
163          */
164         return fasdma_pio;
165 }
166
167 /* Prototype: int powertecscsi_dma_stop(host, SCpnt)
168  * Purpose  : stops DMA/PIO
169  * Params   : host  - host
170  *            SCpnt - command
171  */
172 static void
173 powertecscsi_dma_stop(struct Scsi_Host *host, struct scsi_pointer *SCp)
174 {
175         struct powertec_info *info = (struct powertec_info *)host->hostdata;
176         if (info->info.scsi.dma != NO_DMA)
177                 disable_dma(info->info.scsi.dma);
178 }
179
180 /* Prototype: const char *powertecscsi_info(struct Scsi_Host * host)
181  * Purpose  : returns a descriptive string about this interface,
182  * Params   : host - driver host structure to return info for.
183  * Returns  : pointer to a static buffer containing null terminated string.
184  */
185 const char *powertecscsi_info(struct Scsi_Host *host)
186 {
187         struct powertec_info *info = (struct powertec_info *)host->hostdata;
188         static char string[150];
189
190         sprintf(string, "%s (%s) in slot %d v%s terminators o%s",
191                 host->hostt->name, info->info.scsi.type, info->ec->slot_no,
192                 VERSION, info->term_ctl ? "n" : "ff");
193
194         return string;
195 }
196
197 /* Prototype: int powertecscsi_set_proc_info(struct Scsi_Host *host, char *buffer, int length)
198  * Purpose  : Set a driver specific function
199  * Params   : host   - host to setup
200  *          : buffer - buffer containing string describing operation
201  *          : length - length of string
202  * Returns  : -EINVAL, or 0
203  */
204 static int
205 powertecscsi_set_proc_info(struct Scsi_Host *host, char *buffer, int length)
206 {
207         int ret = length;
208
209         if (length >= 12 && strncmp(buffer, "POWERTECSCSI", 12) == 0) {
210                 buffer += 12;
211                 length -= 12;
212
213                 if (length >= 5 && strncmp(buffer, "term=", 5) == 0) {
214                         if (buffer[5] == '1')
215                                 powertecscsi_terminator_ctl(host, 1);
216                         else if (buffer[5] == '0')
217                                 powertecscsi_terminator_ctl(host, 0);
218                         else
219                                 ret = -EINVAL;
220                 } else
221                         ret = -EINVAL;
222         } else
223                 ret = -EINVAL;
224
225         return ret;
226 }
227
228 /* Prototype: int powertecscsi_proc_info(char *buffer, char **start, off_t offset,
229  *                                      int length, int host_no, int inout)
230  * Purpose  : Return information about the driver to a user process accessing
231  *            the /proc filesystem.
232  * Params   : buffer  - a buffer to write information to
233  *            start   - a pointer into this buffer set by this routine to the start
234  *                      of the required information.
235  *            offset  - offset into information that we have read upto.
236  *            length  - length of buffer
237  *            inout   - 0 for reading, 1 for writing.
238  * Returns  : length of data written to buffer.
239  */
240 int powertecscsi_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
241                             int length, int inout)
242 {
243         struct powertec_info *info;
244         char *p = buffer;
245         int pos;
246
247         if (inout == 1)
248                 return powertecscsi_set_proc_info(host, buffer, length);
249
250         info = (struct powertec_info *)host->hostdata;
251
252         p += sprintf(p, "PowerTec SCSI driver v%s\n", VERSION);
253         p += fas216_print_host(&info->info, p);
254         p += sprintf(p, "Term    : o%s\n",
255                         info->term_ctl ? "n" : "ff");
256
257         p += fas216_print_stats(&info->info, p);
258         p += fas216_print_devices(&info->info, p);
259
260         *start = buffer + offset;
261         pos = p - buffer - offset;
262         if (pos > length)
263                 pos = length;
264
265         return pos;
266 }
267
268 static ssize_t powertecscsi_show_term(struct device *dev, struct device_attribute *attr, char *buf)
269 {
270         struct expansion_card *ec = ECARD_DEV(dev);
271         struct Scsi_Host *host = ecard_get_drvdata(ec);
272         struct powertec_info *info = (struct powertec_info *)host->hostdata;
273
274         return sprintf(buf, "%d\n", info->term_ctl ? 1 : 0);
275 }
276
277 static ssize_t
278 powertecscsi_store_term(struct device *dev, struct device_attribute *attr, const char *buf, size_t len)
279 {
280         struct expansion_card *ec = ECARD_DEV(dev);
281         struct Scsi_Host *host = ecard_get_drvdata(ec);
282
283         if (len > 1)
284                 powertecscsi_terminator_ctl(host, buf[0] != '0');
285
286         return len;
287 }
288
289 static DEVICE_ATTR(bus_term, S_IRUGO | S_IWUSR,
290                    powertecscsi_show_term, powertecscsi_store_term);
291
292 static struct scsi_host_template powertecscsi_template = {
293         .module                         = THIS_MODULE,
294         .proc_info                      = powertecscsi_proc_info,
295         .name                           = "PowerTec SCSI",
296         .info                           = powertecscsi_info,
297         .queuecommand                   = fas216_queue_command,
298         .eh_host_reset_handler          = fas216_eh_host_reset,
299         .eh_bus_reset_handler           = fas216_eh_bus_reset,
300         .eh_device_reset_handler        = fas216_eh_device_reset,
301         .eh_abort_handler               = fas216_eh_abort,
302
303         .can_queue                      = 8,
304         .this_id                        = 7,
305         .sg_tablesize                   = SG_ALL,
306         .cmd_per_lun                    = 2,
307         .use_clustering                 = ENABLE_CLUSTERING,
308         .proc_name                      = "powertec",
309 };
310
311 static int __devinit
312 powertecscsi_probe(struct expansion_card *ec, const struct ecard_id *id)
313 {
314         struct Scsi_Host *host;
315         struct powertec_info *info;
316         void __iomem *base;
317         int ret;
318
319         ret = ecard_request_resources(ec);
320         if (ret)
321                 goto out;
322
323         base = ecardm_iomap(ec, ECARD_RES_IOCFAST, 0, 0);
324         if (!base) {
325                 ret = -ENOMEM;
326                 goto out_region;
327         }
328
329         host = scsi_host_alloc(&powertecscsi_template,
330                                sizeof (struct powertec_info));
331         if (!host) {
332                 ret = -ENOMEM;
333                 goto out_region;
334         }
335
336         ecard_set_drvdata(ec, host);
337
338         info = (struct powertec_info *)host->hostdata;
339         info->base = base;
340         powertecscsi_terminator_ctl(host, term[ec->slot_no]);
341
342         info->ec = ec;
343         info->info.scsi.io_base         = base + POWERTEC_FAS216_OFFSET;
344         info->info.scsi.io_shift        = POWERTEC_FAS216_SHIFT;
345         info->info.scsi.irq             = ec->irq;
346         info->info.scsi.dma             = ec->dma;
347         info->info.ifcfg.clockrate      = 40; /* MHz */
348         info->info.ifcfg.select_timeout = 255;
349         info->info.ifcfg.asyncperiod    = 200; /* ns */
350         info->info.ifcfg.sync_max_depth = 7;
351         info->info.ifcfg.cntl3          = CNTL3_BS8 | CNTL3_FASTSCSI | CNTL3_FASTCLK;
352         info->info.ifcfg.disconnect_ok  = 1;
353         info->info.ifcfg.wide_max_size  = 0;
354         info->info.ifcfg.capabilities   = 0;
355         info->info.dma.setup            = powertecscsi_dma_setup;
356         info->info.dma.pseudo           = NULL;
357         info->info.dma.stop             = powertecscsi_dma_stop;
358
359         ec->irqaddr     = base + POWERTEC_INTR_STATUS;
360         ec->irqmask     = POWERTEC_INTR_BIT;
361
362         ecard_setirq(ec, &powertecscsi_ops, info);
363
364         device_create_file(&ec->dev, &dev_attr_bus_term);
365
366         ret = fas216_init(host);
367         if (ret)
368                 goto out_free;
369
370         ret = request_irq(ec->irq, powertecscsi_intr,
371                           IRQF_DISABLED, "powertec", info);
372         if (ret) {
373                 printk("scsi%d: IRQ%d not free: %d\n",
374                        host->host_no, ec->irq, ret);
375                 goto out_release;
376         }
377
378         if (info->info.scsi.dma != NO_DMA) {
379                 if (request_dma(info->info.scsi.dma, "powertec")) {
380                         printk("scsi%d: DMA%d not free, using PIO\n",
381                                host->host_no, info->info.scsi.dma);
382                         info->info.scsi.dma = NO_DMA;
383                 } else {
384                         set_dma_speed(info->info.scsi.dma, 180);
385                         info->info.ifcfg.capabilities |= FASCAP_DMA;
386                 }
387         }
388
389         ret = fas216_add(host, &ec->dev);
390         if (ret == 0)
391                 goto out;
392
393         if (info->info.scsi.dma != NO_DMA)
394                 free_dma(info->info.scsi.dma);
395         free_irq(ec->irq, host);
396
397  out_release:
398         fas216_release(host);
399
400  out_free:
401         device_remove_file(&ec->dev, &dev_attr_bus_term);
402         scsi_host_put(host);
403
404  out_region:
405         ecard_release_resources(ec);
406
407  out:
408         return ret;
409 }
410
411 static void __devexit powertecscsi_remove(struct expansion_card *ec)
412 {
413         struct Scsi_Host *host = ecard_get_drvdata(ec);
414         struct powertec_info *info = (struct powertec_info *)host->hostdata;
415
416         ecard_set_drvdata(ec, NULL);
417         fas216_remove(host);
418
419         device_remove_file(&ec->dev, &dev_attr_bus_term);
420
421         if (info->info.scsi.dma != NO_DMA)
422                 free_dma(info->info.scsi.dma);
423         free_irq(ec->irq, info);
424
425         fas216_release(host);
426         scsi_host_put(host);
427         ecard_release_resources(ec);
428 }
429
430 static const struct ecard_id powertecscsi_cids[] = {
431         { MANU_ALSYSTEMS, PROD_ALSYS_SCSIATAPI },
432         { 0xffff, 0xffff },
433 };
434
435 static struct ecard_driver powertecscsi_driver = {
436         .probe          = powertecscsi_probe,
437         .remove         = __devexit_p(powertecscsi_remove),
438         .id_table       = powertecscsi_cids,
439         .drv = {
440                 .name           = "powertecscsi",
441         },
442 };
443
444 static int __init powertecscsi_init(void)
445 {
446         return ecard_register_driver(&powertecscsi_driver);
447 }
448
449 static void __exit powertecscsi_exit(void)
450 {
451         ecard_remove_driver(&powertecscsi_driver);
452 }
453
454 module_init(powertecscsi_init);
455 module_exit(powertecscsi_exit);
456
457 MODULE_AUTHOR("Russell King");
458 MODULE_DESCRIPTION("Powertec SCSI driver");
459 module_param_array(term, int, NULL, 0);
460 MODULE_PARM_DESC(term, "SCSI bus termination");
461 MODULE_LICENSE("GPL");