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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
xd.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：36k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

xd.c：源码内容
  1. /*
  2.  * This file contains the driver for an XT hard disk controller
  3.  * (at least the DTC 5150X) for Linux.
  4.  *
  5.  * Author: Pat Mackinlay, pat@it.com.au
  6.  * Date: 29/09/92
  7.  * 
  8.  * Revised: 01/01/93, ...
  9.  *
  10.  * Ref: DTC 5150X Controller Specification (thanks to Kevin Fowler,
  11.  *   kevinf@agora.rain.com)
  12.  * Also thanks to: Salvador Abreu, Dave Thaler, Risto Kankkunen and
  13.  *   Wim Van Dorst.
  14.  *
  15.  * Revised: 04/04/94 by Risto Kankkunen
  16.  *   Moved the detection code from xd_init() to xd_geninit() as it needed
  17.  *   interrupts enabled and Linus didn't want to enable them in that first
  18.  *   phase. xd_geninit() is the place to do these kinds of things anyway,
  19.  *   he says.
  20.  *
  21.  * Modularized: 04/10/96 by Todd Fries, tfries@umr.edu
  22.  *
  23.  * Revised: 13/12/97 by Andrzej Krzysztofowicz, ankry@mif.pg.gda.pl
  24.  *   Fixed some problems with disk initialization and module initiation.
  25.  *   Added support for manual geometry setting (except Seagate controllers)
  26.  *   in form:
  27.  *      xd_geo=<cyl_xda>,<head_xda>,<sec_xda>[,<cyl_xdb>,<head_xdb>,<sec_xdb>]
  28.  *   Recovered DMA access. Abridged messages. Added support for DTC5051CX,
  29.  *   WD1002-27X & XEBEC controllers. Driver uses now some jumper settings.
  30.  *   Extended ioctl() support.
  31.  *
  32.  * Bugfix: 15/02/01, Paul G. - inform queue layer of tiny xd_maxsect.
  33.  *
  34.  */
  36. #include <linux/module.h>
  37. #include <linux/errno.h>
  38. #include <linux/sched.h>
  39. #include <linux/mm.h>
  40. #include <linux/fs.h>
  41. #include <linux/kernel.h>
  42. #include <linux/timer.h>
  43. #include <linux/genhd.h>
  44. #include <linux/hdreg.h>
  45. #include <linux/ioport.h>
  46. #include <linux/init.h>
  47. #include <linux/devfs_fs_kernel.h>
  49. #include <asm/system.h>
  50. #include <asm/io.h>
  51. #include <asm/uaccess.h>
  52. #include <asm/dma.h>
  54. #define MAJOR_NR XT_DISK_MAJOR
  55. #include <linux/blk.h>
  56. #include <linux/blkpg.h>
  58. #include "xd.h"
  60. #define XD_DONT_USE_DMA 0  /* Initial value. may be overriden using
  61.       "nodma" module option */
  62. #define XD_INIT_DISK_DELAY (30*HZ/1000)  /* 30 ms delay during disk initialization */
  64. /* Above may need to be increased if a problem with the 2nd drive detection
  65.    (ST11M controller) or resetting a controller (WD) appears */
  67. XD_INFO xd_info[XD_MAXDRIVES];
  69. /* If you try this driver and find that your card is not detected by the driver at bootup, you need to add your BIOS
  70.    signature and details to the following list of signatures. A BIOS signature is a string embedded into the first
  71.    few bytes of your controller's on-board ROM BIOS. To find out what yours is, use something like MS-DOS's DEBUG
  72.    command. Run DEBUG, and then you can examine your BIOS signature with:
  74. d xxxx:0000
  76.    where xxxx is the segment of your controller (like C800 or D000 or something). On the ASCII dump at the right, you should
  77.    be able to see a string mentioning the manufacturer's copyright etc. Add this string into the table below. The parameters
  78.    in the table are, in order:
  80. offset ; this is the offset (in bytes) from the start of your ROM where the signature starts
  81. signature ; this is the actual text of the signature
  82. xd_?_init_controller ; this is the controller init routine used by your controller
  83. xd_?_init_drive ; this is the drive init routine used by your controller
  85.    The controllers directly supported at the moment are: DTC 5150x, WD 1004A27X, ST11M/R and override. If your controller is
  86.    made by the same manufacturer as one of these, try using the same init routines as they do. If that doesn't work, your
  87.    best bet is to use the "override" routines. These routines use a "portable" method of getting the disk's geometry, and
  88.    may work with your card. If none of these seem to work, try sending me some email and I'll see what I can do <grin>.
  90.    NOTE: You can now specify your XT controller's parameters from the command line in the form xd=TYPE,IRQ,IO,DMA. The driver
  91.    should be able to detect your drive's geometry from this info. (eg: xd=0,5,0x320,3 is the "standard"). */
  93. #include <asm/page.h>
  94. #define xd_dma_mem_alloc(size) __get_dma_pages(GFP_KERNEL,get_order(size))
  95. #define xd_dma_mem_free(addr, size) free_pages(addr, get_order(size))
  96. static char *xd_dma_buffer = 0;
  98. static XD_SIGNATURE xd_sigs[] __initdata = {
  99. { 0x0000,"Override geometry handler",NULL,xd_override_init_drive,"n unknown" }, /* Pat Mackinlay, pat@it.com.au */
  100. { 0x0008,"[BXD06 (C) DTC 17-MAY-1985]",xd_dtc_init_controller,xd_dtc5150cx_init_drive," DTC 5150CX" }, /* Andrzej Krzysztofowicz, ankry@mif.pg.gda.pl */
  101. { 0x000B,"CRD18A   Not an IBM rom. (C) Copyright Data Technology Corp. 05/31/88",xd_dtc_init_controller,xd_dtc_init_drive," DTC 5150X" }, /* Todd Fries, tfries@umr.edu */
  102. { 0x000B,"CXD23A Not an IBM ROM (C)Copyright Data Technology Corp 12/03/88",xd_dtc_init_controller,xd_dtc_init_drive," DTC 5150X" }, /* Pat Mackinlay, pat@it.com.au */
  103. { 0x0008,"07/15/86(C) Copyright 1986 Western Digital Corp.",xd_wd_init_controller,xd_wd_init_drive," Western Dig. 1002-27X" }, /* Andrzej Krzysztofowicz, ankry@mif.pg.gda.pl */
  104. { 0x0008,"06/24/88(C) Copyright 1988 Western Digital Corp.",xd_wd_init_controller,xd_wd_init_drive," Western Dig. WDXT-GEN2" }, /* Dan Newcombe, newcombe@aa.csc.peachnet.edu */
  105. { 0x0015,"SEAGATE ST11 BIOS REVISION",xd_seagate_init_controller,xd_seagate_init_drive," Seagate ST11M/R" }, /* Salvador Abreu, spa@fct.unl.pt */
  106. { 0x0010,"ST11R BIOS",xd_seagate_init_controller,xd_seagate_init_drive," Seagate ST11M/R" }, /* Risto Kankkunen, risto.kankkunen@cs.helsinki.fi */
  107. { 0x0010,"ST11 BIOS v1.7",xd_seagate_init_controller,xd_seagate_init_drive," Seagate ST11R" }, /* Alan Hourihane, alanh@fairlite.demon.co.uk */
  108. { 0x1000,"(c)Copyright 1987 SMS",xd_omti_init_controller,xd_omti_init_drive,"n OMTI 5520" }, /* Dirk Melchers, dirk@merlin.nbg.sub.org */
  109. { 0x0006,"COPYRIGHT XEBEC (C) 1984",xd_xebec_init_controller,xd_xebec_init_drive," XEBEC" }, /* Andrzej Krzysztofowicz, ankry@mif.pg.gda.pl */
  110. };
  112. static unsigned int xd_bases[] __initdata =
  113. {
  114. 0xC8000, 0xCA000, 0xCC000,
  115. 0xCE000, 0xD0000, 0xD2000,
  116. 0xD4000, 0xD6000, 0xD8000,
  117. 0xDA000, 0xDC000, 0xDE000,
  118. 0xE0000
  119. };
  121. static struct hd_struct xd_struct[XD_MAXDRIVES << 6];
  122. static int xd_sizes[XD_MAXDRIVES << 6], xd_access[XD_MAXDRIVES];
  123. static int xd_blocksizes[XD_MAXDRIVES << 6];
  124. static int xd_maxsect[XD_MAXDRIVES << 6];
  126. extern struct block_device_operations xd_fops;
  128. static struct gendisk xd_gendisk = {
  129. major: MAJOR_NR,
  130. major_name: "xd",
  131. minor_shift: 6,
  132. max_p: 1 << 6,
  133. part: xd_struct,
  134. sizes: xd_sizes,
  135. real_devices: (void *)xd_info,
  136. fops: &xd_fops,
  137. };
  139. static struct block_device_operations xd_fops = {
  140. owner: THIS_MODULE,
  141. open: xd_open,
  142. release: xd_release,
  143. ioctl: xd_ioctl,
  144. };
  145. static DECLARE_WAIT_QUEUE_HEAD(xd_wait_int);
  146. static DECLARE_WAIT_QUEUE_HEAD(xd_wait_open);
  147. static u_char xd_valid[XD_MAXDRIVES] = { 0,0 };
  148. static u_char xd_drives, xd_irq = 5, xd_dma = 3, xd_maxsectors;
  149. static u_char xd_override __initdata = 0, xd_type __initdata = 0;
  150. static u_short xd_iobase = 0x320;
  151. static int xd_geo[XD_MAXDRIVES*3] __initdata = { 0, };
  153. static volatile int xdc_busy;
  154. static DECLARE_WAIT_QUEUE_HEAD(xdc_wait);
  156. static struct timer_list xd_timer, xd_watchdog_int;
  158. static volatile u_char xd_error;
  159. static int nodma = XD_DONT_USE_DMA;
  161. static devfs_handle_t devfs_handle = NULL;
  163. /* xd_init: register the block device number and set up pointer tables */
  164. int __init xd_init (void)
  165. {
  166. init_timer (&xd_timer); xd_timer.function = xd_wakeup;
  167. init_timer (&xd_watchdog_int); xd_watchdog_int.function = xd_watchdog;
  169. if (devfs_register_blkdev(MAJOR_NR,"xd",&xd_fops)) {
  170. printk("xd: Unable to get major number %dn",MAJOR_NR);
  171. return -1;
  172. }
  173. devfs_handle = devfs_mk_dir (NULL, xd_gendisk.major_name, NULL);
  174. blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), DEVICE_REQUEST);
  175. read_ahead[MAJOR_NR] = 8; /* 8 sector (4kB) read ahead */
  176. add_gendisk(&xd_gendisk);
  177. xd_geninit();
  179. return 0;
  180. }
  182. /* xd_detect: scan the possible BIOS ROM locations for the signature strings */
  183. static u_char __init xd_detect (u_char *controller, unsigned int *address)
  184. {
  185. u_char i,j,found = 0;
  187. if (xd_override)
  188. {
  189. *controller = xd_type;
  190. *address = 0;
  191. return(1);
  192. }
  194. for (i = 0; i < (sizeof(xd_bases) / sizeof(xd_bases[0])) && !found; i++)
  195. for (j = 1; j < (sizeof(xd_sigs) / sizeof(xd_sigs[0])) && !found; j++)
  196. if (isa_check_signature(xd_bases[i] + xd_sigs[j].offset,xd_sigs[j].string,strlen(xd_sigs[j].string))) {
  197. *controller = j;
  198. xd_type = j;
  199. *address = xd_bases[i];
  200. found++;
  201. }
  202. return (found);
  203. }
  205. /* xd_geninit: grab the IRQ and DMA channel, initialise the drives */
  206. /* and set up the "raw" device entries in the table */
  207. static void __init xd_geninit (void)
  208. {
  209. u_char i,controller;
  210. unsigned int address;
  212. for(i=0;i<(XD_MAXDRIVES << 6);i++) xd_blocksizes[i] = 1024;
  213. blksize_size[MAJOR_NR] = xd_blocksizes;
  215. if (xd_detect(&controller,&address)) {
  217. printk("Detected a%s controller (type %d) at address %06xn",
  218. xd_sigs[controller].name,controller,address);
  219. if (check_region(xd_iobase,4)) {
  220. printk("xd: Ports at 0x%x are not availablen",
  221. xd_iobase);
  222. return;
  223. }
  224. request_region(xd_iobase,4,"xd");
  225. if (controller)
  226. xd_sigs[controller].init_controller(address);
  227. xd_drives = xd_initdrives(xd_sigs[controller].init_drive);
  229. printk("Detected %d hard drive%s (using IRQ%d & DMA%d)n",
  230. xd_drives,xd_drives == 1 ? "" : "s",xd_irq,xd_dma);
  231. for (i = 0; i < xd_drives; i++)
  232. printk(" xd%c: CHS=%d/%d/%dn",'a'+i,
  233. xd_info[i].cylinders,xd_info[i].heads,
  234. xd_info[i].sectors);
  236. }
  237. if (xd_drives) {
  238. if (!request_irq(xd_irq,xd_interrupt_handler, 0, "XT hard disk", NULL)) {
  239. if (request_dma(xd_dma,"xd")) {
  240. printk("xd: unable to get DMA%dn",xd_dma);
  241. free_irq(xd_irq, NULL);
  242. }
  243. }
  244. else
  245. printk("xd: unable to get IRQ%dn",xd_irq);
  246. }
  248. /* xd_maxsectors depends on controller - so set after detection */
  249. for(i=0; i<(XD_MAXDRIVES << 6); i++) xd_maxsect[i] = xd_maxsectors;
  250. max_sectors[MAJOR_NR] = xd_maxsect;
  252. for (i = 0; i < xd_drives; i++) {
  253. xd_valid[i] = 1;
  254. register_disk(&xd_gendisk, MKDEV(MAJOR_NR,i<<6), 1<<6, &xd_fops,
  255. xd_info[i].heads * xd_info[i].cylinders *
  256. xd_info[i].sectors);
  257. }
  259. xd_gendisk.nr_real = xd_drives;
  261. }
  263. /* xd_open: open a device */
  264. static int xd_open (struct inode *inode,struct file *file)
  265. {
  266. int dev = DEVICE_NR(inode->i_rdev);
  268. if (dev < xd_drives) {
  269. while (!xd_valid[dev])
  270. sleep_on(&xd_wait_open);
  272. xd_access[dev]++;
  274. return (0);
  275. }
  277. return -ENXIO;
  278. }
  280. /* do_xd_request: handle an incoming request */
  281. static void do_xd_request (request_queue_t * q)
  282. {
  283. u_int block,count,retry;
  284. int code;
  286. sti();
  287. if (xdc_busy)
  288. return;
  289. while (code = 0, !QUEUE_EMPTY) {
  290. INIT_REQUEST; /* do some checking on the request structure */
  292. if (CURRENT_DEV < xd_drives
  293.     && CURRENT->sector + CURRENT->nr_sectors
  294.          <= xd_struct[MINOR(CURRENT->rq_dev)].nr_sects) {
  295. block = CURRENT->sector + xd_struct[MINOR(CURRENT->rq_dev)].start_sect;
  296. count = CURRENT->nr_sectors;
  298. switch (CURRENT->cmd) {
  299. case READ:
  300. case WRITE:
  301. for (retry = 0; (retry < XD_RETRIES) && !code; retry++)
  302. code = xd_readwrite(CURRENT->cmd,CURRENT_DEV,CURRENT->buffer,block,count);
  303. break;
  304. default:
  305. printk("do_xd_request: unknown requestn");
  306. break;
  307. }
  308. }
  309. end_request(code); /* wrap up, 0 = fail, 1 = success */
  310. }
  311. }
  313. /* xd_ioctl: handle device ioctl's */
  314. static int xd_ioctl (struct inode *inode,struct file *file,u_int cmd,u_long arg)
  315. {
  316. int dev;
  318. if ((!inode) || !(inode->i_rdev))
  319. return -EINVAL;
  320.   dev = DEVICE_NR(inode->i_rdev);
  322. if (dev >= xd_drives) return -EINVAL;
  323. switch (cmd) {
  324. case HDIO_GETGEO:
  325. {
  326. struct hd_geometry g;
  327. struct hd_geometry *geometry = (struct hd_geometry *) arg;
  328. if (!geometry) return -EINVAL;
  329. g.heads = xd_info[dev].heads;
  330. g.sectors = xd_info[dev].sectors;
  331. g.cylinders = xd_info[dev].cylinders;
  332. g.start = xd_struct[MINOR(inode->i_rdev)].start_sect;
  333. return copy_to_user(geometry, &g, sizeof g) ? -EFAULT : 0;
  334. }
  335. case HDIO_SET_DMA:
  336. if (!capable(CAP_SYS_ADMIN)) return -EACCES;
  337. if (xdc_busy) return -EBUSY;
  338. nodma = !arg;
  339. if (nodma && xd_dma_buffer) {
  340. xd_dma_mem_free((unsigned long)xd_dma_buffer, xd_maxsectors * 0x200);
  341. xd_dma_buffer = 0;
  342. }
  343. return 0;
  344. case HDIO_GET_DMA:
  345. return put_user(!nodma, (long *) arg);
  346. case HDIO_GET_MULTCOUNT:
  347. return put_user(xd_maxsectors, (long *) arg);
  348. case BLKRRPART:
  349. if (!capable(CAP_SYS_ADMIN)) 
  350. return -EACCES;
  351. return xd_reread_partitions(inode->i_rdev);
  353. case BLKGETSIZE:
  354. case BLKGETSIZE64:
  355. case BLKFLSBUF:
  356. case BLKROSET:
  357. case BLKROGET:
  358. case BLKRASET:
  359. case BLKRAGET:
  360. case BLKPG:
  361. return blk_ioctl(inode->i_rdev, cmd, arg);
  363. default:
  364. return -EINVAL;
  365. }
  366. }
  368. /* xd_release: release the device */
  369. static int xd_release (struct inode *inode, struct file *file)
  370. {
  371. int target = DEVICE_NR(inode->i_rdev);
  372. if (target < xd_drives)
  373. xd_access[target]--;
  374. return 0;
  375. }
  377. /* xd_reread_partitions: rereads the partition table from a drive */
  378. static int xd_reread_partitions(kdev_t dev)
  379. {
  380. int target;
  381. int start;
  382. int partition;
  384. target = DEVICE_NR(dev);
  385.   start = target << xd_gendisk.minor_shift;
  387. cli();
  388. xd_valid[target] = (xd_access[target] != 1);
  389.         sti();
  390. if (xd_valid[target])
  391. return -EBUSY;
  393. for (partition = xd_gendisk.max_p - 1; partition >= 0; partition--) {
  394. int minor = (start | partition);
  395. invalidate_device(MKDEV(MAJOR_NR, minor), 1);
  396. xd_gendisk.part[minor].start_sect = 0;
  397. xd_gendisk.part[minor].nr_sects = 0;
  398. };
  400. grok_partitions(&xd_gendisk, target, 1<<6,
  401. xd_info[target].heads * xd_info[target].cylinders * xd_info[target].sectors);
  403. xd_valid[target] = 1;
  404. wake_up(&xd_wait_open);
  406. return 0;
  407. }
  409. /* xd_readwrite: handle a read/write request */
  410. static int xd_readwrite (u_char operation,u_char drive,char *buffer,u_int block,u_int count)
  411. {
  412. u_char cmdblk[6],sense[4];
  413. u_short track,cylinder;
  414. u_char head,sector,control,mode = PIO_MODE,temp;
  415. char **real_buffer;
  416. register int i;
  418. #ifdef DEBUG_READWRITE
  419. printk("xd_readwrite: operation = %s, drive = %d, buffer = 0x%X, block = %d, count = %dn",operation == READ ? "read" : "write",drive,buffer,block,count);
  420. #endif /* DEBUG_READWRITE */
  422. control = xd_info[drive].control;
  423. if (!xd_dma_buffer)
  424. xd_dma_buffer = (char *)xd_dma_mem_alloc(xd_maxsectors * 0x200);
  425. while (count) {
  426. temp = count < xd_maxsectors ? count : xd_maxsectors;
  428. track = block / xd_info[drive].sectors;
  429. head = track % xd_info[drive].heads;
  430. cylinder = track / xd_info[drive].heads;
  431. sector = block % xd_info[drive].sectors;
  433. #ifdef DEBUG_READWRITE
  434. printk("xd_readwrite: drive = %d, head = %d, cylinder = %d, sector = %d, count = %dn",drive,head,cylinder,sector,temp);
  435. #endif /* DEBUG_READWRITE */
  437. if (xd_dma_buffer) {
  438. mode = xd_setup_dma(operation == READ ? DMA_MODE_READ : DMA_MODE_WRITE,(u_char *)(xd_dma_buffer),temp * 0x200);
  439. real_buffer = &xd_dma_buffer;
  440. for (i=0; i < (temp * 0x200); i++)
  441. xd_dma_buffer[i] = buffer[i];
  442. }
  443. else
  444. real_buffer = &buffer;
  446. xd_build(cmdblk,operation == READ ? CMD_READ : CMD_WRITE,drive,head,cylinder,sector,temp & 0xFF,control);
  448. switch (xd_command(cmdblk,mode,(u_char *)(*real_buffer),(u_char *)(*real_buffer),sense,XD_TIMEOUT)) {
  449. case 1:
  450. printk("xd%c: %s timeout, recalibrating driven",'a'+drive,(operation == READ ? "read" : "write"));
  451. xd_recalibrate(drive);
  452. return (0);
  453. case 2:
  454. if (sense[0] & 0x30) {
  455. printk("xd%c: %s - ",'a'+drive,(operation == READ ? "reading" : "writing"));
  456. switch ((sense[0] & 0x30) >> 4) {
  457. case 0: printk("drive error, code = 0x%X",sense[0] & 0x0F);
  458. break;
  459. case 1: printk("controller error, code = 0x%X",sense[0] & 0x0F);
  460. break;
  461. case 2: printk("command error, code = 0x%X",sense[0] & 0x0F);
  462. break;
  463. case 3: printk("miscellaneous error, code = 0x%X",sense[0] & 0x0F);
  464. break;
  465. }
  466. }
  467. if (sense[0] & 0x80)
  468. printk(" - CHS = %d/%d/%dn",((sense[2] & 0xC0) << 2) | sense[3],sense[1] & 0x1F,sense[2] & 0x3F);
  469. /* reported drive number = (sense[1] & 0xE0) >> 5 */
  470. else
  471. printk(" - no valid disk addressn");
  472. return (0);
  473. }
  474. if (xd_dma_buffer)
  475. for (i=0; i < (temp * 0x200); i++)
  476. buffer[i] = xd_dma_buffer[i];
  478. count -= temp, buffer += temp * 0x200, block += temp;
  479. }
  480. return (1);
  481. }
  483. /* xd_recalibrate: recalibrate a given drive and reset controller if necessary */
  484. static void xd_recalibrate (u_char drive)
  485. {
  486. u_char cmdblk[6];
  488. xd_build(cmdblk,CMD_RECALIBRATE,drive,0,0,0,0,0);
  489. if (xd_command(cmdblk,PIO_MODE,0,0,0,XD_TIMEOUT * 8))
  490. printk("xd%c: warning! error recalibrating, controller may be unstablen", 'a'+drive);
  491. }
  493. /* xd_interrupt_handler: interrupt service routine */
  494. static void xd_interrupt_handler(int irq, void *dev_id, struct pt_regs * regs)
  495. {
  496. if (inb(XD_STATUS) & STAT_INTERRUPT) { /* check if it was our device */
  497. #ifdef DEBUG_OTHER
  498. printk("xd_interrupt_handler: interrupt detectedn");
  499. #endif /* DEBUG_OTHER */
  500. outb(0,XD_CONTROL); /* acknowledge interrupt */
  501. wake_up(&xd_wait_int); /* and wake up sleeping processes */
  502. }
  503. else
  504. printk("xd: unexpected interruptn");
  505. }
  507. /* xd_setup_dma: set up the DMA controller for a data transfer */
  508. static u_char xd_setup_dma (u_char mode,u_char *buffer,u_int count)
  509. {
  510. unsigned long f;
  512. if (nodma)
  513. return (PIO_MODE);
  514. if (((unsigned long) buffer & 0xFFFF0000) != (((unsigned long) buffer + count) & 0xFFFF0000)) {
  515. #ifdef DEBUG_OTHER
  516. printk("xd_setup_dma: using PIO, transfer overlaps 64k boundaryn");
  517. #endif /* DEBUG_OTHER */
  518. return (PIO_MODE);
  519. }
  521. f=claim_dma_lock();
  522. disable_dma(xd_dma);
  523. clear_dma_ff(xd_dma);
  524. set_dma_mode(xd_dma,mode);
  525. set_dma_addr(xd_dma, (unsigned long) buffer);
  526. set_dma_count(xd_dma,count);
  528. release_dma_lock(f);
  530. return (DMA_MODE); /* use DMA and INT */
  531. }
  533. /* xd_build: put stuff into an array in a format suitable for the controller */
  534. static u_char *xd_build (u_char *cmdblk,u_char command,u_char drive,u_char head,u_short cylinder,u_char sector,u_char count,u_char control)
  535. {
  536. cmdblk[0] = command;
  537. cmdblk[1] = ((drive & 0x07) << 5) | (head & 0x1F);
  538. cmdblk[2] = ((cylinder & 0x300) >> 2) | (sector & 0x3F);
  539. cmdblk[3] = cylinder & 0xFF;
  540. cmdblk[4] = count;
  541. cmdblk[5] = control;
  543. return (cmdblk);
  544. }
  546. /* xd_wakeup is called from timer interrupt */
  547. static void xd_wakeup (unsigned long unused)
  548. {
  549. wake_up(&xdc_wait);
  550. }
  552. /* xd_wakeup is called from timer interrupt */
  553. static void xd_watchdog (unsigned long unused)
  554. {
  555. xd_error = 1;
  556. wake_up(&xd_wait_int);
  557. }
  559. /* xd_waitport: waits until port & mask == flags or a timeout occurs. return 1 for a timeout */
  560. static inline u_char xd_waitport (u_short port,u_char flags,u_char mask,u_long timeout)
  561. {
  562. u_long expiry = jiffies + timeout;
  563. int success;
  565. xdc_busy = 1;
  566. while ((success = ((inb(port) & mask) != flags)) && time_before(jiffies, expiry)) {
  567. xd_timer.expires = jiffies;
  568. cli();
  569. add_timer(&xd_timer);
  570. sleep_on(&xdc_wait);
  571. del_timer(&xd_timer);
  572. sti();
  573. }
  574. xdc_busy = 0;
  575. return (success);
  576. }
  578. static inline u_int xd_wait_for_IRQ (void)
  579. {
  580. unsigned long flags;
  581. xd_watchdog_int.expires = jiffies + 8 * HZ;
  582. add_timer(&xd_watchdog_int);
  584. flags=claim_dma_lock();
  585. enable_dma(xd_dma);
  586. release_dma_lock(flags);
  588. sleep_on(&xd_wait_int);
  589. del_timer(&xd_watchdog_int);
  590. xdc_busy = 0;
  592. flags=claim_dma_lock();
  593. disable_dma(xd_dma);
  594. release_dma_lock(flags);
  596. if (xd_error) {
  597. printk("xd: missed IRQ - command abortedn");
  598. xd_error = 0;
  599. return (1);
  600. }
  601. return (0);
  602. }
  604. /* xd_command: handle all data transfers necessary for a single command */
  605. static u_int xd_command (u_char *command,u_char mode,u_char *indata,u_char *outdata,u_char *sense,u_long timeout)
  606. {
  607. u_char cmdblk[6],csb,complete = 0;
  609. #ifdef DEBUG_COMMAND
  610. printk("xd_command: command = 0x%X, mode = 0x%X, indata = 0x%X, outdata = 0x%X, sense = 0x%Xn",command,mode,indata,outdata,sense);
  611. #endif /* DEBUG_COMMAND */
  613. outb(0,XD_SELECT);
  614. outb(mode,XD_CONTROL);
  616. if (xd_waitport(XD_STATUS,STAT_SELECT,STAT_SELECT,timeout))
  617. return (1);
  619. while (!complete) {
  620. if (xd_waitport(XD_STATUS,STAT_READY,STAT_READY,timeout))
  621. return (1);
  623. switch (inb(XD_STATUS) & (STAT_COMMAND | STAT_INPUT)) {
  624. case 0:
  625. if (mode == DMA_MODE) {
  626. if (xd_wait_for_IRQ())
  627. return (1);
  628. } else
  629. outb(outdata ? *outdata++ : 0,XD_DATA);
  630. break;
  631. case STAT_INPUT:
  632. if (mode == DMA_MODE) {
  633. if (xd_wait_for_IRQ())
  634. return (1);
  635. } else
  636. if (indata)
  637. *indata++ = inb(XD_DATA);
  638. else
  639. inb(XD_DATA);
  640. break;
  641. case STAT_COMMAND:
  642. outb(command ? *command++ : 0,XD_DATA);
  643. break;
  644. case STAT_COMMAND | STAT_INPUT:
  645. complete = 1;
  646. break;
  647. }
  648. }
  649. csb = inb(XD_DATA);
  651. if (xd_waitport(XD_STATUS,0,STAT_SELECT,timeout)) /* wait until deselected */
  652. return (1);
  654. if (csb & CSB_ERROR) { /* read sense data if error */
  655. xd_build(cmdblk,CMD_SENSE,(csb & CSB_LUN) >> 5,0,0,0,0,0);
  656. if (xd_command(cmdblk,0,sense,0,0,XD_TIMEOUT))
  657. printk("xd: warning! sense command failed!n");
  658. }
  660. #ifdef DEBUG_COMMAND
  661. printk("xd_command: completed with csb = 0x%Xn",csb);
  662. #endif /* DEBUG_COMMAND */
  664. return (csb & CSB_ERROR);
  665. }
  667. static u_char __init xd_initdrives (void (*init_drive)(u_char drive))
  668. {
  669. u_char cmdblk[6],i,count = 0;
  671. for (i = 0; i < XD_MAXDRIVES; i++) {
  672. xd_build(cmdblk,CMD_TESTREADY,i,0,0,0,0,0);
  673. if (!xd_command(cmdblk,PIO_MODE,0,0,0,XD_TIMEOUT * 8)) {
  674.   xd_timer.expires = jiffies + XD_INIT_DISK_DELAY;
  675. add_timer(&xd_timer);
  676. sleep_on(&xdc_wait);
  678. init_drive(count);
  679. count++;
  681.   xd_timer.expires = jiffies + XD_INIT_DISK_DELAY;
  682. add_timer(&xd_timer);
  683. sleep_on(&xdc_wait);
  684. }
  685. }
  686. return (count);
  687. }
  689. static void __init xd_manual_geo_set (u_char drive)
  690. {
  691. xd_info[drive].heads = (u_char)(xd_geo[3 * drive + 1]);
  692. xd_info[drive].cylinders = (u_short)(xd_geo[3 * drive]);
  693. xd_info[drive].sectors = (u_char)(xd_geo[3 * drive + 2]);
  694. }
  696. static void __init xd_dtc_init_controller (unsigned int address)
  697. {
  698. switch (address) {
  699. case 0x00000:
  700. case 0xC8000: break; /*initial: 0x320 */
  701. case 0xCA000: xd_iobase = 0x324; 
  702. case 0xD0000: /*5150CX*/
  703. case 0xD8000: break; /*5150CX & 5150XL*/
  704. default:        printk("xd_dtc_init_controller: unsupported BIOS address %06xn",address);
  705. break;
  706. }
  707. xd_maxsectors = 0x01; /* my card seems to have trouble doing multi-block transfers? */
  709. outb(0,XD_RESET); /* reset the controller */
  710. }
  713. static void __init xd_dtc5150cx_init_drive (u_char drive)
  714. {
  715. /* values from controller's BIOS - BIOS chip may be removed */
  716. static u_short geometry_table[][4] = {
  717. {0x200,8,0x200,0x100},
  718. {0x267,2,0x267,0x267},
  719. {0x264,4,0x264,0x80},
  720. {0x132,4,0x132,0x0},
  721. {0x132,2,0x80, 0x132},
  722. {0x177,8,0x177,0x0},
  723. {0x132,8,0x84, 0x0},
  724. {},  /* not used */
  725. {0x132,6,0x80, 0x100},
  726. {0x200,6,0x100,0x100},
  727. {0x264,2,0x264,0x80},
  728. {0x280,4,0x280,0x100},
  729. {0x2B9,3,0x2B9,0x2B9},
  730. {0x2B9,5,0x2B9,0x2B9},
  731. {0x280,6,0x280,0x100},
  732. {0x132,4,0x132,0x0}};
  733. u_char n;
  735. n = inb(XD_JUMPER);
  736. n = (drive ? n : (n >> 2)) & 0x33;
  737. n = (n | (n >> 2)) & 0x0F;
  738. if (xd_geo[3*drive])
  739. xd_manual_geo_set(drive);
  740. else
  741. if (n != 7) {
  742. xd_info[drive].heads = (u_char)(geometry_table[n][1]); /* heads */
  743. xd_info[drive].cylinders = geometry_table[n][0]; /* cylinders */
  744. xd_info[drive].sectors = 17; /* sectors */
  745. #if 0
  746. xd_info[drive].rwrite = geometry_table[n][2]; /* reduced write */
  747. xd_info[drive].precomp = geometry_table[n][3] /* write precomp */
  748. xd_info[drive].ecc = 0x0B; /* ecc length */
  749. #endif /* 0 */
  750. }
  751. else {
  752. printk("xd%c: undetermined drive geometryn",'a'+drive);
  753. return;
  754. }
  755. xd_info[drive].control = 5; /* control byte */
  756. xd_setparam(CMD_DTCSETPARAM,drive,xd_info[drive].heads,xd_info[drive].cylinders,geometry_table[n][2],geometry_table[n][3],0x0B);
  757. xd_recalibrate(drive);
  758. }
  760. static void __init xd_dtc_init_drive (u_char drive)
  761. {
  762. u_char cmdblk[6],buf[64];
  764. xd_build(cmdblk,CMD_DTCGETGEOM,drive,0,0,0,0,0);
  765. if (!xd_command(cmdblk,PIO_MODE,buf,0,0,XD_TIMEOUT * 2)) {
  766. xd_info[drive].heads = buf[0x0A]; /* heads */
  767. xd_info[drive].cylinders = ((u_short *) (buf))[0x04]; /* cylinders */
  768. xd_info[drive].sectors = 17; /* sectors */
  769. if (xd_geo[3*drive])
  770. xd_manual_geo_set(drive);
  771. #if 0
  772. xd_info[drive].rwrite = ((u_short *) (buf + 1))[0x05]; /* reduced write */
  773. xd_info[drive].precomp = ((u_short *) (buf + 1))[0x06]; /* write precomp */
  774. xd_info[drive].ecc = buf[0x0F]; /* ecc length */
  775. #endif /* 0 */
  776. xd_info[drive].control = 0; /* control byte */
  778. xd_setparam(CMD_DTCSETPARAM,drive,xd_info[drive].heads,xd_info[drive].cylinders,((u_short *) (buf + 1))[0x05],((u_short *) (buf + 1))[0x06],buf[0x0F]);
  779. xd_build(cmdblk,CMD_DTCSETSTEP,drive,0,0,0,0,7);
  780. if (xd_command(cmdblk,PIO_MODE,0,0,0,XD_TIMEOUT * 2))
  781. printk("xd_dtc_init_drive: error setting step rate for xd%cn", 'a'+drive);
  782. }
  783. else
  784. printk("xd_dtc_init_drive: error reading geometry for xd%cn", 'a'+drive);
  785. }
  787. static void __init xd_wd_init_controller (unsigned int address)
  788. {
  789. switch (address) {
  790. case 0x00000:
  791. case 0xC8000: break; /*initial: 0x320 */
  792. case 0xCA000: xd_iobase = 0x324; break;
  793. case 0xCC000:   xd_iobase = 0x328; break;
  794. case 0xCE000:   xd_iobase = 0x32C; break;
  795. case 0xD0000: xd_iobase = 0x328; break; /* ? */
  796. case 0xD8000: xd_iobase = 0x32C; break; /* ? */
  797. default:        printk("xd_wd_init_controller: unsupported BIOS address %06xn",address);
  798. break;
  799. }
  800. xd_maxsectors = 0x01; /* this one doesn't wrap properly either... */
  802. outb(0,XD_RESET); /* reset the controller */
  804. xd_timer.expires = jiffies + XD_INIT_DISK_DELAY;
  805. add_timer(&xd_timer);
  806. sleep_on(&xdc_wait);
  807. }
  809. static void __init xd_wd_init_drive (u_char drive)
  810. {
  811. /* values from controller's BIOS - BIOS may be disabled */
  812. static u_short geometry_table[][4] = {
  813. {0x264,4,0x1C2,0x1C2},   /* common part */
  814. {0x132,4,0x099,0x0},
  815. {0x267,2,0x1C2,0x1C2},
  816. {0x267,4,0x1C2,0x1C2},
  818. {0x334,6,0x335,0x335},   /* 1004 series RLL */
  819. {0x30E,4,0x30F,0x3DC},
  820. {0x30E,2,0x30F,0x30F},
  821. {0x267,4,0x268,0x268},
  823. {0x3D5,5,0x3D6,0x3D6},   /* 1002 series RLL */
  824. {0x3DB,7,0x3DC,0x3DC},
  825. {0x264,4,0x265,0x265},
  826. {0x267,4,0x268,0x268}};
  828. u_char cmdblk[6],buf[0x200];
  829. u_char n = 0,rll,jumper_state,use_jumper_geo;
  830. u_char wd_1002 = (xd_sigs[xd_type].string[7] == '6');
  832. jumper_state = ~(inb(0x322));
  833. if (jumper_state & 0x40)
  834. xd_irq = 9;
  835. rll = (jumper_state & 0x30) ? (0x04 << wd_1002) : 0;
  836. xd_build(cmdblk,CMD_READ,drive,0,0,0,1,0);
  837. if (!xd_command(cmdblk,PIO_MODE,buf,0,0,XD_TIMEOUT * 2)) {
  838. xd_info[drive].heads = buf[0x1AF]; /* heads */
  839. xd_info[drive].cylinders = ((u_short *) (buf + 1))[0xD6]; /* cylinders */
  840. xd_info[drive].sectors = 17; /* sectors */
  841. if (xd_geo[3*drive])
  842. xd_manual_geo_set(drive);
  843. #if 0
  844. xd_info[drive].rwrite = ((u_short *) (buf))[0xD8]; /* reduced write */
  845. xd_info[drive].wprecomp = ((u_short *) (buf))[0xDA]; /* write precomp */
  846. xd_info[drive].ecc = buf[0x1B4]; /* ecc length */
  847. #endif /* 0 */
  848. xd_info[drive].control = buf[0x1B5]; /* control byte */
  849. use_jumper_geo = !(xd_info[drive].heads) || !(xd_info[drive].cylinders);
  850. if (xd_geo[3*drive]) {
  851. xd_manual_geo_set(drive);
  852. xd_info[drive].control = rll ? 7 : 5;
  853. }
  854. else if (use_jumper_geo) {
  855. n = (((jumper_state & 0x0F) >> (drive << 1)) & 0x03) | rll;
  856. xd_info[drive].cylinders = geometry_table[n][0];
  857. xd_info[drive].heads = (u_char)(geometry_table[n][1]);
  858. xd_info[drive].control = rll ? 7 : 5;
  859. #if 0
  860. xd_info[drive].rwrite = geometry_table[n][2];
  861. xd_info[drive].wprecomp = geometry_table[n][3];
  862. xd_info[drive].ecc = 0x0B;
  863. #endif /* 0 */
  864. }
  865. if (!wd_1002) {
  866. if (use_jumper_geo)
  867. xd_setparam(CMD_WDSETPARAM,drive,xd_info[drive].heads,xd_info[drive].cylinders,
  868. geometry_table[n][2],geometry_table[n][3],0x0B);
  869. else
  870. xd_setparam(CMD_WDSETPARAM,drive,xd_info[drive].heads,xd_info[drive].cylinders,
  871. ((u_short *) (buf))[0xD8],((u_short *) (buf))[0xDA],buf[0x1B4]);
  872. }
  873. /* 1002 based RLL controller requests converted addressing, but reports physical 
  874.    (physical 26 sec., logical 17 sec.) 
  875.    1004 based ???? */
  876. if (rll & wd_1002) {
  877. if ((xd_info[drive].cylinders *= 26,
  878.      xd_info[drive].cylinders /= 17) > 1023)
  879. xd_info[drive].cylinders = 1023;  /* 1024 ? */
  880. #if 0
  881. xd_info[drive].rwrite *= 26; 
  882. xd_info[drive].rwrite /= 17;
  883. xd_info[drive].wprecomp *= 26
  884. xd_info[drive].wprecomp /= 17;
  885. #endif /* 0 */
  886. }
  887. }
  888. else
  889. printk("xd_wd_init_drive: error reading geometry for xd%cn",'a'+drive);
  891. }
  893. static void __init xd_seagate_init_controller (unsigned int address)
  894. {
  895. switch (address) {
  896. case 0x00000:
  897. case 0xC8000: break; /*initial: 0x320 */
  898. case 0xD0000: xd_iobase = 0x324; break;
  899. case 0xD8000: xd_iobase = 0x328; break;
  900. case 0xE0000: xd_iobase = 0x32C; break;
  901. default: printk("xd_seagate_init_controller: unsupported BIOS address %06xn",address);
  902. break;
  903. }
  904. xd_maxsectors = 0x40;
  906. outb(0,XD_RESET); /* reset the controller */
  907. }
  909. static void __init xd_seagate_init_drive (u_char drive)
  910. {
  911. u_char cmdblk[6],buf[0x200];
  913. xd_build(cmdblk,CMD_ST11GETGEOM,drive,0,0,0,1,0);
  914. if (!xd_command(cmdblk,PIO_MODE,buf,0,0,XD_TIMEOUT * 2)) {
  915. xd_info[drive].heads = buf[0x04]; /* heads */
  916. xd_info[drive].cylinders = (buf[0x02] << 8) | buf[0x03]; /* cylinders */
  917. xd_info[drive].sectors = buf[0x05]; /* sectors */
  918. xd_info[drive].control = 0; /* control byte */
  919. }
  920. else
  921. printk("xd_seagate_init_drive: error reading geometry from xd%cn", 'a'+drive);
  922. }
  924. /* Omti support courtesy Dirk Melchers */
  925. static void __init xd_omti_init_controller (unsigned int address)
  926. {
  927. switch (address) {
  928. case 0x00000:
  929. case 0xC8000: break; /*initial: 0x320 */
  930. case 0xD0000: xd_iobase = 0x324; break;
  931. case 0xD8000: xd_iobase = 0x328; break;
  932. case 0xE0000: xd_iobase = 0x32C; break;
  933. default: printk("xd_omti_init_controller: unsupported BIOS address %06xn",address);
  934. break;
  935. }
  937. xd_maxsectors = 0x40;
  939. outb(0,XD_RESET); /* reset the controller */
  940. }
  942. static void __init xd_omti_init_drive (u_char drive)
  943. {
  944. /* gets infos from drive */
  945. xd_override_init_drive(drive);
  947. /* set other parameters, Hardcoded, not that nice :-) */
  948. xd_info[drive].control = 2;
  949. }
  951. /* Xebec support (AK) */
  952. static void __init xd_xebec_init_controller (unsigned int address)
  953. {
  954. /* iobase may be set manually in range 0x300 - 0x33C
  955.       irq may be set manually to 2(9),3,4,5,6,7
  956.       dma may be set manually to 1,2,3
  957. (How to detect them ???)
  958. BIOS address may be set manually in range 0x0 - 0xF8000
  959. If you need non-standard settings use the xd=... command */
  961. switch (address) {
  962. case 0x00000:
  963. case 0xC8000: /* initially: xd_iobase==0x320 */
  964. case 0xD0000:
  965. case 0xD2000:
  966. case 0xD4000:
  967. case 0xD6000:
  968. case 0xD8000:
  969. case 0xDA000:
  970. case 0xDC000:
  971. case 0xDE000:
  972. case 0xE0000: break;
  973. default: printk("xd_xebec_init_controller: unsupported BIOS address %06xn",address);
  974. break;
  975. }
  977. xd_maxsectors = 0x01;
  978. outb(0,XD_RESET); /* reset the controller */
  980. xd_timer.expires = jiffies + XD_INIT_DISK_DELAY;
  981. add_timer(&xd_timer);
  982. sleep_on(&xdc_wait);
  983. }
  985. static void __init xd_xebec_init_drive (u_char drive)
  986. {
  987. /* values from controller's BIOS - BIOS chip may be removed */
  988. static u_short geometry_table[][5] = {
  989. {0x132,4,0x080,0x080,0x7},
  990. {0x132,4,0x080,0x080,0x17},
  991. {0x264,2,0x100,0x100,0x7},
  992. {0x264,2,0x100,0x100,0x17},
  993. {0x132,8,0x080,0x080,0x7},
  994. {0x132,8,0x080,0x080,0x17},
  995. {0x264,4,0x100,0x100,0x6},
  996. {0x264,4,0x100,0x100,0x17},
  997. {0x2BC,5,0x2BC,0x12C,0x6},
  998. {0x3A5,4,0x3A5,0x3A5,0x7},
  999. {0x26C,6,0x26C,0x26C,0x7},
  1000. {0x200,8,0x200,0x100,0x17},
  1001. {0x400,5,0x400,0x400,0x7},
  1002. {0x400,6,0x400,0x400,0x7},
  1003. {0x264,8,0x264,0x200,0x17},
  1004. {0x33E,7,0x33E,0x200,0x7}};
  1005. u_char n;
  1007. n = inb(XD_JUMPER) & 0x0F; /* BIOS's drive number: same geometry 
  1008. is assumed for BOTH drives */
  1009. if (xd_geo[3*drive])
  1010. xd_manual_geo_set(drive);
  1011. else {
  1012. xd_info[drive].heads = (u_char)(geometry_table[n][1]); /* heads */
  1013. xd_info[drive].cylinders = geometry_table[n][0]; /* cylinders */
  1014. xd_info[drive].sectors = 17; /* sectors */
  1015. #if 0
  1016. xd_info[drive].rwrite = geometry_table[n][2]; /* reduced write */
  1017. xd_info[drive].precomp = geometry_table[n][3] /* write precomp */
  1018. xd_info[drive].ecc = 0x0B; /* ecc length */
  1019. #endif /* 0 */
  1020. }
  1021. xd_info[drive].control = geometry_table[n][4]; /* control byte */
  1022. xd_setparam(CMD_XBSETPARAM,drive,xd_info[drive].heads,xd_info[drive].cylinders,geometry_table[n][2],geometry_table[n][3],0x0B);
  1023. xd_recalibrate(drive);
  1024. }
  1026. /* xd_override_init_drive: this finds disk geometry in a "binary search" style, narrowing in on the "correct" number of heads
  1027.    etc. by trying values until it gets the highest successful value. Idea courtesy Salvador Abreu (spa@fct.unl.pt). */
  1028. static void __init xd_override_init_drive (u_char drive)
  1029. {
  1030. u_short min[] = { 0,0,0 },max[] = { 16,1024,64 },test[] = { 0,0,0 };
  1031. u_char cmdblk[6],i;
  1033. if (xd_geo[3*drive])
  1034. xd_manual_geo_set(drive);
  1035. else {
  1036. for (i = 0; i < 3; i++) {
  1037. while (min[i] != max[i] - 1) {
  1038. test[i] = (min[i] + max[i]) / 2;
  1039. xd_build(cmdblk,CMD_SEEK,drive,(u_char) test[0],(u_short) test[1],(u_char) test[2],0,0);
  1040. if (!xd_command(cmdblk,PIO_MODE,0,0,0,XD_TIMEOUT * 2))
  1041. min[i] = test[i];
  1042. else
  1043. max[i] = test[i];
  1044. }
  1045. test[i] = min[i];
  1046. }
  1047. xd_info[drive].heads = (u_char) min[0] + 1;
  1048. xd_info[drive].cylinders = (u_short) min[1] + 1;
  1049. xd_info[drive].sectors = (u_char) min[2] + 1;
  1050. }
  1051. xd_info[drive].control = 0;
  1052. }
  1054. /* xd_setup: initialise controller from command line parameters */
  1055. void __init do_xd_setup (int *integers)
  1056. {
  1057. switch (integers[0]) {
  1058. case 4: if (integers[4] < 0)
  1059. nodma = 1;
  1060. else if (integers[4] < 8)
  1061. xd_dma = integers[4];
  1062. case 3: if ((integers[3] > 0) && (integers[3] <= 0x3FC))
  1063. xd_iobase = integers[3];
  1064. case 2: if ((integers[2] > 0) && (integers[2] < 16))
  1065. xd_irq = integers[2];
  1066. case 1: xd_override = 1;
  1067. if ((integers[1] >= 0) && (integers[1] < (sizeof(xd_sigs) / sizeof(xd_sigs[0]))))
  1068. xd_type = integers[1];
  1069. case 0: break;
  1070. default:printk("xd: too many parameters for xdn");
  1071. }
  1072. xd_maxsectors = 0x01;
  1073. }
  1075. /* xd_setparam: set the drive characteristics */
  1076. static void __init xd_setparam (u_char command,u_char drive,u_char heads,u_short cylinders,u_short rwrite,u_short wprecomp,u_char ecc)
  1077. {
  1078. u_char cmdblk[14];
  1080. xd_build(cmdblk,command,drive,0,0,0,0,0);
  1081. cmdblk[6] = (u_char) (cylinders >> 8) & 0x03;
  1082. cmdblk[7] = (u_char) (cylinders & 0xFF);
  1083. cmdblk[8] = heads & 0x1F;
  1084. cmdblk[9] = (u_char) (rwrite >> 8) & 0x03;
  1085. cmdblk[10] = (u_char) (rwrite & 0xFF);
  1086. cmdblk[11] = (u_char) (wprecomp >> 8) & 0x03;
  1087. cmdblk[12] = (u_char) (wprecomp & 0xFF);
  1088. cmdblk[13] = ecc;
  1090. /* Some controllers require geometry info as data, not command */
  1092. if (xd_command(cmdblk,PIO_MODE,0,&cmdblk[6],0,XD_TIMEOUT * 2))
  1093. printk("xd: error setting characteristics for xd%cn", 'a'+drive);
  1094. }
  1097. #ifdef MODULE
  1098. static int xd[5] = { -1,-1,-1,-1, };
  1100. MODULE_PARM(xd, "1-4i");
  1101. MODULE_PARM(xd_geo, "3-6i");
  1102. MODULE_PARM(nodma, "i");
  1104. MODULE_LICENSE("GPL");
  1106. static void xd_done (void)
  1107. {
  1108. blksize_size[MAJOR_NR] = NULL;
  1109. blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
  1110. blk_size[MAJOR_NR] = NULL;
  1111. hardsect_size[MAJOR_NR] = NULL;
  1112. read_ahead[MAJOR_NR] = 0;
  1113. del_gendisk(&xd_gendisk);
  1114. release_region(xd_iobase,4);
  1115. }
  1117. int init_module(void)
  1118. {
  1119. int i,count = 0;
  1120. int error;
  1122. for (i = 4; i > 0; i--)
  1123. if(((xd[i] = xd[i-1]) >= 0) && !count)
  1124. count = i;
  1125. if((xd[0] = count))
  1126. do_xd_setup(xd);
  1128. error = xd_init();
  1129. if (error) return error;
  1131. printk(KERN_INFO "XD: Loaded as a module.n");
  1132. if (!xd_drives) {
  1133. /* no drives detected - unload module */
  1134. devfs_unregister_blkdev(MAJOR_NR, "xd");
  1135. xd_done();
  1136. return (-1);
  1137. }
  1138.         
  1139. return 0;
  1140. }
  1142. void cleanup_module(void)
  1143. {
  1144. devfs_unregister_blkdev(MAJOR_NR, "xd");
  1145. xd_done();
  1146. devfs_unregister (devfs_handle);
  1147. if (xd_drives) {
  1148. free_irq(xd_irq, NULL);
  1149. free_dma(xd_dma);
  1150. if (xd_dma_buffer)
  1151. xd_dma_mem_free((unsigned long)xd_dma_buffer, xd_maxsectors * 0x200);
  1152. }
  1153. }
  1154. #else
  1156. static int __init xd_setup (char *str)
  1157. {
  1158. int ints[5];
  1159. get_options (str, ARRAY_SIZE (ints), ints);
  1160. do_xd_setup (ints);
  1161. return 1;
  1162. }
  1164. /* xd_manual_geo_init: initialise drive geometry from command line parameters
  1165.    (used only for WD drives) */
  1166. static int __init xd_manual_geo_init (char *str)
  1167. {
  1168. int i, integers[1 + 3*XD_MAXDRIVES];
  1170. get_options (str, ARRAY_SIZE (integers), integers);
  1171. if (integers[0]%3 != 0) {
  1172. printk("xd: incorrect number of parameters for xd_geon");
  1173. return 1;
  1174. }
  1175. for (i = 0; (i < integers[0]) && (i < 3*XD_MAXDRIVES); i++)
  1176. xd_geo[i] = integers[i+1];
  1177. return 1;
  1178. }
  1180. __setup ("xd=", xd_setup);
  1181. __setup ("xd_geo=", xd_manual_geo_init);
  1183. #endif /* MODULE */