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"); 462