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 up to. 236 * length - length of buffer 237 * inout - 0 for reading, 1 for writing. 238 * Returns : length of data written to buffer. 239 */ 240 static int powertecscsi_show_info(struct seq_file *m, struct Scsi_Host *host) 241 { 242 struct powertec_info *info; 243 244 info = (struct powertec_info *)host->hostdata; 245 246 seq_printf(m, "PowerTec SCSI driver v%s\n", VERSION); 247 fas216_print_host(&info->info, m); 248 seq_printf(m, "Term : o%s\n", 249 info->term_ctl ? "n" : "ff"); 250 251 fas216_print_stats(&info->info, m); 252 fas216_print_devices(&info->info, m); 253 return 0; 254 } 255 256 static ssize_t powertecscsi_show_term(struct device *dev, struct device_attribute *attr, char *buf) 257 { 258 struct expansion_card *ec = ECARD_DEV(dev); 259 struct Scsi_Host *host = ecard_get_drvdata(ec); 260 struct powertec_info *info = (struct powertec_info *)host->hostdata; 261 262 return sprintf(buf, "%d\n", info->term_ctl ? 1 : 0); 263 } 264 265 static ssize_t 266 powertecscsi_store_term(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) 267 { 268 struct expansion_card *ec = ECARD_DEV(dev); 269 struct Scsi_Host *host = ecard_get_drvdata(ec); 270 271 if (len > 1) 272 powertecscsi_terminator_ctl(host, buf[0] != '0'); 273 274 return len; 275 } 276 277 static DEVICE_ATTR(bus_term, S_IRUGO | S_IWUSR, 278 powertecscsi_show_term, powertecscsi_store_term); 279 280 static struct scsi_host_template powertecscsi_template = { 281 .module = THIS_MODULE, 282 .show_info = powertecscsi_show_info, 283 .write_info = powertecscsi_set_proc_info, 284 .name = "PowerTec SCSI", 285 .info = powertecscsi_info, 286 .queuecommand = fas216_queue_command, 287 .eh_host_reset_handler = fas216_eh_host_reset, 288 .eh_bus_reset_handler = fas216_eh_bus_reset, 289 .eh_device_reset_handler = fas216_eh_device_reset, 290 .eh_abort_handler = fas216_eh_abort, 291 292 .can_queue = 8, 293 .this_id = 7, 294 .sg_tablesize = SG_MAX_SEGMENTS, 295 .dma_boundary = IOMD_DMA_BOUNDARY, 296 .cmd_per_lun = 2, 297 .proc_name = "powertec", 298 }; 299 300 static int powertecscsi_probe(struct expansion_card *ec, 301 const struct ecard_id *id) 302 { 303 struct Scsi_Host *host; 304 struct powertec_info *info; 305 void __iomem *base; 306 int ret; 307 308 ret = ecard_request_resources(ec); 309 if (ret) 310 goto out; 311 312 base = ecardm_iomap(ec, ECARD_RES_IOCFAST, 0, 0); 313 if (!base) { 314 ret = -ENOMEM; 315 goto out_region; 316 } 317 318 host = scsi_host_alloc(&powertecscsi_template, 319 sizeof (struct powertec_info)); 320 if (!host) { 321 ret = -ENOMEM; 322 goto out_region; 323 } 324 325 ecard_set_drvdata(ec, host); 326 327 info = (struct powertec_info *)host->hostdata; 328 info->base = base; 329 powertecscsi_terminator_ctl(host, term[ec->slot_no]); 330 331 info->ec = ec; 332 info->info.scsi.io_base = base + POWERTEC_FAS216_OFFSET; 333 info->info.scsi.io_shift = POWERTEC_FAS216_SHIFT; 334 info->info.scsi.irq = ec->irq; 335 info->info.scsi.dma = ec->dma; 336 info->info.ifcfg.clockrate = 40; /* MHz */ 337 info->info.ifcfg.select_timeout = 255; 338 info->info.ifcfg.asyncperiod = 200; /* ns */ 339 info->info.ifcfg.sync_max_depth = 7; 340 info->info.ifcfg.cntl3 = CNTL3_BS8 | CNTL3_FASTSCSI | CNTL3_FASTCLK; 341 info->info.ifcfg.disconnect_ok = 1; 342 info->info.ifcfg.wide_max_size = 0; 343 info->info.ifcfg.capabilities = 0; 344 info->info.dma.setup = powertecscsi_dma_setup; 345 info->info.dma.pseudo = NULL; 346 info->info.dma.stop = powertecscsi_dma_stop; 347 348 ec->irqaddr = base + POWERTEC_INTR_STATUS; 349 ec->irqmask = POWERTEC_INTR_BIT; 350 351 ecard_setirq(ec, &powertecscsi_ops, info); 352 353 device_create_file(&ec->dev, &dev_attr_bus_term); 354 355 ret = fas216_init(host); 356 if (ret) 357 goto out_free; 358 359 ret = request_irq(ec->irq, powertecscsi_intr, 360 0, "powertec", info); 361 if (ret) { 362 printk("scsi%d: IRQ%d not free: %d\n", 363 host->host_no, ec->irq, ret); 364 goto out_release; 365 } 366 367 if (info->info.scsi.dma != NO_DMA) { 368 if (request_dma(info->info.scsi.dma, "powertec")) { 369 printk("scsi%d: DMA%d not free, using PIO\n", 370 host->host_no, info->info.scsi.dma); 371 info->info.scsi.dma = NO_DMA; 372 } else { 373 set_dma_speed(info->info.scsi.dma, 180); 374 info->info.ifcfg.capabilities |= FASCAP_DMA; 375 } 376 } 377 378 ret = fas216_add(host, &ec->dev); 379 if (ret == 0) 380 goto out; 381 382 if (info->info.scsi.dma != NO_DMA) 383 free_dma(info->info.scsi.dma); 384 free_irq(ec->irq, host); 385 386 out_release: 387 fas216_release(host); 388 389 out_free: 390 device_remove_file(&ec->dev, &dev_attr_bus_term); 391 scsi_host_put(host); 392 393 out_region: 394 ecard_release_resources(ec); 395 396 out: 397 return ret; 398 } 399 400 static void powertecscsi_remove(struct expansion_card *ec) 401 { 402 struct Scsi_Host *host = ecard_get_drvdata(ec); 403 struct powertec_info *info = (struct powertec_info *)host->hostdata; 404 405 ecard_set_drvdata(ec, NULL); 406 fas216_remove(host); 407 408 device_remove_file(&ec->dev, &dev_attr_bus_term); 409 410 if (info->info.scsi.dma != NO_DMA) 411 free_dma(info->info.scsi.dma); 412 free_irq(ec->irq, info); 413 414 fas216_release(host); 415 scsi_host_put(host); 416 ecard_release_resources(ec); 417 } 418 419 static const struct ecard_id powertecscsi_cids[] = { 420 { MANU_ALSYSTEMS, PROD_ALSYS_SCSIATAPI }, 421 { 0xffff, 0xffff }, 422 }; 423 424 static struct ecard_driver powertecscsi_driver = { 425 .probe = powertecscsi_probe, 426 .remove = powertecscsi_remove, 427 .id_table = powertecscsi_cids, 428 .drv = { 429 .name = "powertecscsi", 430 }, 431 }; 432 433 static int __init powertecscsi_init(void) 434 { 435 return ecard_register_driver(&powertecscsi_driver); 436 } 437 438 static void __exit powertecscsi_exit(void) 439 { 440 ecard_remove_driver(&powertecscsi_driver); 441 } 442 443 module_init(powertecscsi_init); 444 module_exit(powertecscsi_exit); 445 446 MODULE_AUTHOR("Russell King"); 447 MODULE_DESCRIPTION("Powertec SCSI driver"); 448 module_param_array(term, int, NULL, 0); 449 MODULE_PARM_DESC(term, "SCSI bus termination"); 450 MODULE_LICENSE("GPL"); 451