开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
powertec.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：14k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

powertec.c：源码内容
  1. /*
  2.  *  linux/drivers/acorn/scsi/powertec.c
  3.  *
  4.  *  Copyright (C) 1997-2000 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.  * This driver is based on experimentation.  Hence, it may have made
  11.  * assumptions about the particular card that I have available, and
  12.  * may not be reliable!
  13.  *
  14.  * Changelog:
  15.  *  01-10-1997 RMK Created, READONLY version.
  16.  *  15-02-1998 RMK Added DMA support and hardware definitions.
  17.  *  15-04-1998 RMK Only do PIO if FAS216 will allow it.
  18.  *  02-05-1998 RMK Moved DMA sg list into per-interface structure.
  19.  *  27-06-1998 RMK Changed asm/delay.h to linux/delay.h
  20.  *  02-04-2000 RMK Updated for new error handling code.
  21.  */
  22. #include <linux/module.h>
  23. #include <linux/blk.h>
  24. #include <linux/kernel.h>
  25. #include <linux/string.h>
  26. #include <linux/ioport.h>
  27. #include <linux/sched.h>
  28. #include <linux/proc_fs.h>
  29. #include <linux/unistd.h>
  30. #include <linux/stat.h>
  31. #include <linux/delay.h>
  32. #include <linux/pci.h>
  33. #include <linux/init.h>
  35. #include <asm/dma.h>
  36. #include <asm/ecard.h>
  37. #include <asm/io.h>
  38. #include <asm/irq.h>
  39. #include <asm/pgtable.h>
  41. #include "../../scsi/sd.h"
  42. #include "../../scsi/hosts.h"
  43. #include "fas216.h"
  45. #include <scsi/scsicam.h>
  47. /* Configuration */
  48. #define POWERTEC_XTALFREQ 40
  49. #define POWERTEC_ASYNC_PERIOD 200
  50. #define POWERTEC_SYNC_DEPTH 7
  52. /*
  53.  * List of devices that the driver will recognise
  54.  */
  55. #define POWERTECSCSI_LIST { MANU_ALSYSTEMS, PROD_ALSYS_SCSIATAPI }
  57. #define POWERTEC_FAS216_OFFSET 0xc00
  58. #define POWERTEC_FAS216_SHIFT 4
  60. #define POWERTEC_INTR_STATUS 0x800
  61. #define POWERTEC_INTR_BIT 0x80
  63. #define POWERTEC_RESET_CONTROL 0x406
  64. #define POWERTEC_RESET_BIT 1
  66. #define POWERTEC_TERM_CONTROL 0x806
  67. #define POWERTEC_TERM_ENABLE 1
  69. #define POWERTEC_INTR_CONTROL 0x407
  70. #define POWERTEC_INTR_ENABLE 1
  71. #define POWERTEC_INTR_DISABLE 0
  73. /*
  74.  * Version
  75.  */
  76. #define VER_MAJOR 0
  77. #define VER_MINOR 0
  78. #define VER_PATCH 5
  80. static struct expansion_card *ecs[MAX_ECARDS];
  82. /*
  83.  * Use term=0,1,0,0,0 to turn terminators on/off
  84.  */
  85. static int term[MAX_ECARDS] = { 1, 1, 1, 1, 1, 1, 1, 1 };
  87. #define NR_SG 256
  89. typedef struct {
  90. FAS216_Info info;
  92. struct {
  93. unsigned int term_port;
  94. unsigned int terms;
  95. } control;
  97. /* other info... */
  98. struct scatterlist sg[NR_SG]; /* Scatter DMA list */
  99. } PowerTecScsi_Info;
  101. /* Prototype: void powertecscsi_irqenable(ec, irqnr)
  102.  * Purpose  : Enable interrupts on Powertec SCSI card
  103.  * Params   : ec    - expansion card structure
  104.  *          : irqnr - interrupt number
  105.  */
  106. static void
  107. powertecscsi_irqenable(struct expansion_card *ec, int irqnr)
  108. {
  109. unsigned int port = (unsigned int)ec->irq_data;
  110. outb(POWERTEC_INTR_ENABLE, port);
  111. }
  113. /* Prototype: void powertecscsi_irqdisable(ec, irqnr)
  114.  * Purpose  : Disable interrupts on Powertec SCSI card
  115.  * Params   : ec    - expansion card structure
  116.  *          : irqnr - interrupt number
  117.  */
  118. static void
  119. powertecscsi_irqdisable(struct expansion_card *ec, int irqnr)
  120. {
  121. unsigned int port = (unsigned int)ec->irq_data;
  122. outb(POWERTEC_INTR_DISABLE, port);
  123. }
  125. static const expansioncard_ops_t powertecscsi_ops = {
  126. powertecscsi_irqenable,
  127. powertecscsi_irqdisable,
  128. NULL,
  129. NULL,
  130. NULL,
  131. NULL
  132. };
  134. /* Prototype: void powertecscsi_terminator_ctl(host, on_off)
  135.  * Purpose  : Turn the Powertec SCSI terminators on or off
  136.  * Params   : host   - card to turn on/off
  137.  *          : on_off - !0 to turn on, 0 to turn off
  138.  */
  139. static void
  140. powertecscsi_terminator_ctl(struct Scsi_Host *host, int on_off)
  141. {
  142. PowerTecScsi_Info *info = (PowerTecScsi_Info *)host->hostdata;
  144. if (on_off)
  145. info->control.terms = POWERTEC_TERM_ENABLE;
  146. else
  147. info->control.terms = 0;
  149. outb(info->control.terms, info->control.term_port);
  150. }
  152. /* Prototype: void powertecscsi_intr(irq, *dev_id, *regs)
  153.  * Purpose  : handle interrupts from Powertec SCSI card
  154.  * Params   : irq    - interrupt number
  155.  *       dev_id - user-defined (Scsi_Host structure)
  156.  *       regs   - processor registers at interrupt
  157.  */
  158. static void
  159. powertecscsi_intr(int irq, void *dev_id, struct pt_regs *regs)
  160. {
  161. struct Scsi_Host *host = (struct Scsi_Host *)dev_id;
  163. fas216_intr(host);
  164. }
  166. /* Prototype: fasdmatype_t powertecscsi_dma_setup(host, SCpnt, direction, min_type)
  167.  * Purpose  : initialises DMA/PIO
  168.  * Params   : host      - host
  169.  *       SCpnt     - command
  170.  *       direction - DMA on to/off of card
  171.  *       min_type  - minimum DMA support that we must have for this transfer
  172.  * Returns  : type of transfer to be performed
  173.  */
  174. static fasdmatype_t
  175. powertecscsi_dma_setup(struct Scsi_Host *host, Scsi_Pointer *SCp,
  176.        fasdmadir_t direction, fasdmatype_t min_type)
  177. {
  178. PowerTecScsi_Info *info = (PowerTecScsi_Info *)host->hostdata;
  179. int dmach = host->dma_channel;
  181. if (dmach != NO_DMA &&
  182.     (min_type == fasdma_real_all || SCp->this_residual >= 512)) {
  183. int bufs = SCp->buffers_residual;
  184. int pci_dir, dma_dir;
  186. if (bufs)
  187. memcpy(info->sg + 1, SCp->buffer + 1,
  188. sizeof(struct scatterlist) * bufs);
  189. info->sg[0].address = SCp->ptr;
  190. info->sg[0].page    = NULL;
  191. info->sg[0].length  = SCp->this_residual;
  193. if (direction == DMA_OUT)
  194. pci_dir = PCI_DMA_TODEVICE,
  195. dma_dir = DMA_MODE_WRITE;
  196. else
  197. pci_dir = PCI_DMA_FROMDEVICE,
  198. dma_dir = DMA_MODE_READ;
  200. pci_map_sg(NULL, info->sg, bufs + 1, pci_dir);
  202. disable_dma(dmach);
  203. set_dma_sg(dmach, info->sg, bufs + 1);
  204. set_dma_mode(dmach, dma_dir);
  205. enable_dma(dmach);
  206. return fasdma_real_all;
  207. }
  209. /*
  210.  * If we're not doing DMA,
  211.  *  we'll do slow PIO
  212.  */
  213. return fasdma_pio;
  214. }
  216. /* Prototype: int powertecscsi_dma_stop(host, SCpnt)
  217.  * Purpose  : stops DMA/PIO
  218.  * Params   : host  - host
  219.  *       SCpnt - command
  220.  */
  221. static void
  222. powertecscsi_dma_stop(struct Scsi_Host *host, Scsi_Pointer *SCp)
  223. {
  224. if (host->dma_channel != NO_DMA)
  225. disable_dma(host->dma_channel);
  226. }
  228. /* Prototype: int powertecscsi_detect(Scsi_Host_Template * tpnt)
  229.  * Purpose  : initialises PowerTec SCSI driver
  230.  * Params   : tpnt - template for this SCSI adapter
  231.  * Returns  : >0 if host found, 0 otherwise.
  232.  */
  233. int
  234. powertecscsi_detect(Scsi_Host_Template *tpnt)
  235. {
  236. static const card_ids powertecscsi_cids[] =
  237. { POWERTECSCSI_LIST, { 0xffff, 0xffff} };
  238. int count = 0;
  239. struct Scsi_Host *host;
  240.   
  241. tpnt->proc_name = "powertec";
  242. memset(ecs, 0, sizeof (ecs));
  244. ecard_startfind();
  246. while (1) {
  247.      PowerTecScsi_Info *info;
  249. ecs[count] = ecard_find(0, powertecscsi_cids);
  250. if (!ecs[count])
  251. break;
  253. ecard_claim(ecs[count]);
  255. host = scsi_register(tpnt, sizeof (PowerTecScsi_Info));
  256. if (!host) {
  257. ecard_release(ecs[count]);
  258. break;
  259. }
  261. host->io_port = ecard_address(ecs[count], ECARD_IOC, ECARD_FAST);
  262. host->irq = ecs[count]->irq;
  263. host->dma_channel = ecs[count]->dma;
  264. info = (PowerTecScsi_Info *)host->hostdata;
  266. if (host->dma_channel != NO_DMA)
  267. set_dma_speed(host->dma_channel, 180);
  269. info->control.term_port = host->io_port + POWERTEC_TERM_CONTROL;
  270. info->control.terms = term[count] ? POWERTEC_TERM_ENABLE : 0;
  271. powertecscsi_terminator_ctl(host, info->control.terms);
  273. info->info.scsi.io_port =
  274. host->io_port + POWERTEC_FAS216_OFFSET;
  275. info->info.scsi.io_shift= POWERTEC_FAS216_SHIFT;
  276. info->info.scsi.irq = host->irq;
  277. info->info.ifcfg.clockrate = POWERTEC_XTALFREQ;
  278. info->info.ifcfg.select_timeout = 255;
  279. info->info.ifcfg.asyncperiod = POWERTEC_ASYNC_PERIOD;
  280. info->info.ifcfg.sync_max_depth = POWERTEC_SYNC_DEPTH;
  281. info->info.ifcfg.cntl3 = CNTL3_BS8 | CNTL3_FASTSCSI | CNTL3_FASTCLK;
  282. info->info.ifcfg.disconnect_ok = 1;
  283. info->info.ifcfg.wide_max_size = 0;
  284. info->info.dma.setup = powertecscsi_dma_setup;
  285. info->info.dma.pseudo = NULL;
  286. info->info.dma.stop = powertecscsi_dma_stop;
  288. ecs[count]->irqaddr = (unsigned char *)
  289.     ioaddr(host->io_port + POWERTEC_INTR_STATUS);
  290. ecs[count]->irqmask = POWERTEC_INTR_BIT;
  291. ecs[count]->irq_data = (void *)
  292.     (host->io_port + POWERTEC_INTR_CONTROL);
  293. ecs[count]->ops = (expansioncard_ops_t *)&powertecscsi_ops;
  295. request_region(host->io_port + POWERTEC_FAS216_OFFSET,
  296.        16 << POWERTEC_FAS216_SHIFT, "powertec2-fas");
  298. if (host->irq != NO_IRQ &&
  299.     request_irq(host->irq, powertecscsi_intr,
  300. SA_INTERRUPT, "powertec", host)) {
  301. printk("scsi%d: IRQ%d not free, interrupts disabledn",
  302.        host->host_no, host->irq);
  303. host->irq = NO_IRQ;
  304. info->info.scsi.irq = NO_IRQ;
  305. }
  307. if (host->dma_channel != NO_DMA &&
  308.     request_dma(host->dma_channel, "powertec")) {
  309. printk("scsi%d: DMA%d not free, DMA disabledn",
  310.        host->host_no, host->dma_channel);
  311. host->dma_channel = NO_DMA;
  312. }
  314. fas216_init(host);
  315. ++count;
  316. }
  317. return count;
  318. }
  320. /* Prototype: int powertecscsi_release(struct Scsi_Host * host)
  321.  * Purpose  : releases all resources used by this adapter
  322.  * Params   : host - driver host structure to return info for.
  323.  */
  324. int powertecscsi_release(struct Scsi_Host *host)
  325. {
  326. int i;
  328. fas216_release(host);
  330. if (host->irq != NO_IRQ)
  331. free_irq(host->irq, host);
  332. if (host->dma_channel != NO_DMA)
  333. free_dma(host->dma_channel);
  334. release_region(host->io_port + POWERTEC_FAS216_OFFSET,
  335.        16 << POWERTEC_FAS216_SHIFT);
  337. for (i = 0; i < MAX_ECARDS; i++)
  338. if (ecs[i] &&
  339.     host->io_port == ecard_address(ecs[i], ECARD_IOC, ECARD_FAST))
  340. ecard_release(ecs[i]);
  341. return 0;
  342. }
  344. /* Prototype: const char *powertecscsi_info(struct Scsi_Host * host)
  345.  * Purpose  : returns a descriptive string about this interface,
  346.  * Params   : host - driver host structure to return info for.
  347.  * Returns  : pointer to a static buffer containing null terminated string.
  348.  */
  349. const char *powertecscsi_info(struct Scsi_Host *host)
  350. {
  351. PowerTecScsi_Info *info = (PowerTecScsi_Info *)host->hostdata;
  352. static char string[100], *p;
  354. p = string;
  355. p += sprintf(p, "%s ", host->hostt->name);
  356. p += fas216_info(&info->info, p);
  357. p += sprintf(p, "v%d.%d.%d terminators o%s",
  358.      VER_MAJOR, VER_MINOR, VER_PATCH,
  359.      info->control.terms ? "n" : "ff");
  361. return string;
  362. }
  364. /* Prototype: int powertecscsi_set_proc_info(struct Scsi_Host *host, char *buffer, int length)
  365.  * Purpose  : Set a driver specific function
  366.  * Params   : host   - host to setup
  367.  *          : buffer - buffer containing string describing operation
  368.  *          : length - length of string
  369.  * Returns  : -EINVAL, or 0
  370.  */
  371. static int
  372. powertecscsi_set_proc_info(struct Scsi_Host *host, char *buffer, int length)
  373. {
  374. int ret = length;
  376. if (length >= 12 && strncmp(buffer, "POWERTECSCSI", 12) == 0) {
  377. buffer += 12;
  378. length -= 12;
  380. if (length >= 5 && strncmp(buffer, "term=", 5) == 0) {
  381. if (buffer[5] == '1')
  382. powertecscsi_terminator_ctl(host, 1);
  383. else if (buffer[5] == '0')
  384. powertecscsi_terminator_ctl(host, 0);
  385. else
  386. ret = -EINVAL;
  387. } else
  388. ret = -EINVAL;
  389. } else
  390. ret = -EINVAL;
  392. return ret;
  393. }
  395. /* Prototype: int powertecscsi_proc_info(char *buffer, char **start, off_t offset,
  396.  * int length, int host_no, int inout)
  397.  * Purpose  : Return information about the driver to a user process accessing
  398.  *       the /proc filesystem.
  399.  * Params   : buffer  - a buffer to write information to
  400.  *       start   - a pointer into this buffer set by this routine to the start
  401.  *         of the required information.
  402.  *       offset  - offset into information that we have read upto.
  403.  *       length  - length of buffer
  404.  *       host_no - host number to return information for
  405.  *       inout   - 0 for reading, 1 for writing.
  406.  * Returns  : length of data written to buffer.
  407.  */
  408. int powertecscsi_proc_info(char *buffer, char **start, off_t offset,
  409.     int length, int host_no, int inout)
  410. {
  411. int pos, begin;
  412. struct Scsi_Host *host = scsi_hostlist;
  413. PowerTecScsi_Info *info;
  414. Scsi_Device *scd;
  416. while (host) {
  417. if (host->host_no == host_no)
  418. break;
  419. host = host->next;
  420. }
  421. if (!host)
  422. return 0;
  424. if (inout == 1)
  425. return powertecscsi_set_proc_info(host, buffer, length);
  427. info = (PowerTecScsi_Info *)host->hostdata;
  429. begin = 0;
  430. pos = sprintf(buffer,
  431. "PowerTec SCSI driver version %d.%d.%dn",
  432. VER_MAJOR, VER_MINOR, VER_PATCH);
  434. pos += fas216_print_host(&info->info, buffer + pos);
  435. pos += sprintf(buffer + pos, "Term    : o%sn",
  436. info->control.terms ? "n" : "ff");
  438. pos += fas216_print_stats(&info->info, buffer + pos);
  440. pos += sprintf(buffer+pos, "nAttached devices:n");
  442. for (scd = host->host_queue; scd; scd = scd->next) {
  443. pos += fas216_print_device(&info->info, scd, buffer + pos);
  445. if (pos + begin < offset) {
  446. begin += pos;
  447. pos = 0;
  448. }
  449. if (pos + begin > offset + length)
  450. break;
  451. }
  453. *start = buffer + (offset - begin);
  454. pos -= offset - begin;
  455. if (pos > length)
  456. pos = length;
  458. return pos;
  459. }
  461. static Scsi_Host_Template powertecscsi_template = {
  462. module: THIS_MODULE,
  463. proc_info: powertecscsi_proc_info,
  464. name: "PowerTec SCSI",
  465. detect: powertecscsi_detect,
  466. release: powertecscsi_release,
  467. info: powertecscsi_info,
  468. bios_param: scsicam_bios_param,
  469. can_queue: 1,
  470. this_id: 7,
  471. sg_tablesize: SG_ALL,
  472. cmd_per_lun: 1,
  473. use_clustering: ENABLE_CLUSTERING,
  474. command: fas216_command,
  475. queuecommand: fas216_queue_command,
  476. eh_host_reset_handler: fas216_eh_host_reset,
  477. eh_bus_reset_handler: fas216_eh_bus_reset,
  478. eh_device_reset_handler: fas216_eh_device_reset,
  479. eh_abort_handler: fas216_eh_abort,
  480. use_new_eh_code: 1
  481. };
  483. static int __init powertecscsi_init(void)
  484. {
  485. scsi_register_module(MODULE_SCSI_HA, &powertecscsi_template);
  486. if (powertecscsi_template.present)
  487. return 0;
  489. scsi_unregister_module(MODULE_SCSI_HA, &powertecscsi_template);
  490. return -ENODEV;
  491. }
  493. static void __exit powertecscsi_exit(void)
  494. {
  495. scsi_unregister_module(MODULE_SCSI_HA, &powertecscsi_template);
  496. }
  498. module_init(powertecscsi_init);
  499. module_exit(powertecscsi_exit);
  501. MODULE_AUTHOR("Russell King");
  502. MODULE_DESCRIPTION("Powertec SCSI driver");
  503. MODULE_PARM(term, "1-8i");
  504. MODULE_PARM_DESC(term, "SCSI bus termination");
  505. MODULE_LICENSE("GPL");
  506. EXPORT_NO_SYMBOLS;