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

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

Linux/Unix编程

开发平台：

Unix_Linux

ide-disk.c：源码内容
  1. /*
  2.  *  linux/drivers/ide/ide-disk.c Version 1.10 June 9, 2000
  3.  *
  4.  *  Copyright (C) 1994-1998  Linus Torvalds & authors (see below)
  5.  */
  7. /*
  8.  *  Mostly written by Mark Lord <mlord@pobox.com>
  9.  *                and Gadi Oxman <gadio@netvision.net.il>
  10.  *                and Andre Hedrick <andre@linux-ide.org>
  11.  *
  12.  * This is the IDE/ATA disk driver, as evolved from hd.c and ide.c.
  13.  *
  14.  * Version 1.00 move disk only code from ide.c to ide-disk.c
  15.  * support optional byte-swapping of all data
  16.  * Version 1.01 fix previous byte-swapping code
  17.  * Version 1.02 remove ", LBA" from drive identification msgs
  18.  * Version 1.03 fix display of id->buf_size for big-endian
  19.  * Version 1.04 add /proc configurable settings and S.M.A.R.T support
  20.  * Version 1.05 add capacity support for ATA3 >= 8GB
  21.  * Version 1.06 get boot-up messages to show full cyl count
  22.  * Version 1.07 disable door-locking if it fails
  23.  * Version 1.08 fixed CHS/LBA translations for ATA4 > 8GB,
  24.  * process of adding new ATA4 compliance.
  25.  * fixed problems in allowing fdisk to see
  26.  * the entire disk.
  27.  * Version 1.09 added increment of rq->sector in ide_multwrite
  28.  * added UDMA 3/4 reporting
  29.  * Version 1.10 request queue changes, Ultra DMA 100
  30.  * Version 1.11 added 48-bit lba
  31.  * Version 1.12 adding taskfile io access method
  32.  * Highmem I/O support, Jens Axboe <axboe@suse.de>
  33.  */
  35. #define IDEDISK_VERSION "1.12"
  37. #undef REALLY_SLOW_IO /* most systems can safely undef this */
  39. #include <linux/config.h>
  40. #include <linux/module.h>
  41. #include <linux/types.h>
  42. #include <linux/string.h>
  43. #include <linux/kernel.h>
  44. #include <linux/timer.h>
  45. #include <linux/mm.h>
  46. #include <linux/interrupt.h>
  47. #include <linux/major.h>
  48. #include <linux/errno.h>
  49. #include <linux/genhd.h>
  50. #include <linux/slab.h>
  51. #include <linux/delay.h>
  52. #include <linux/ide.h>
  54. #include <asm/byteorder.h>
  55. #include <asm/irq.h>
  56. #include <asm/uaccess.h>
  57. #include <asm/io.h>
  59. #ifdef CONFIG_BLK_DEV_PDC4030
  60. #define IS_PDC4030_DRIVE (HWIF(drive)->chipset == ide_pdc4030)
  61. #else
  62. #define IS_PDC4030_DRIVE (0) /* auto-NULLs out pdc4030 code */
  63. #endif
  65. #ifdef CONFIG_IDE_TASKFILE_IO
  66. #  undef __TASKFILE__IO /* define __TASKFILE__IO */
  67. #else /* CONFIG_IDE_TASKFILE_IO */
  68. #  undef __TASKFILE__IO
  69. #endif /* CONFIG_IDE_TASKFILE_IO */
  71. #ifndef __TASKFILE__IO
  73. static void idedisk_bswap_data (void *buffer, int wcount)
  74. {
  75. u16 *p = buffer;
  77. while (wcount--) {
  78. *p = *p << 8 | *p >> 8; p++;
  79. *p = *p << 8 | *p >> 8; p++;
  80. }
  81. }
  83. static inline void idedisk_input_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
  84. {
  85. ide_input_data(drive, buffer, wcount);
  86. if (drive->bswap)
  87. idedisk_bswap_data(buffer, wcount);
  88. }
  90. static inline void idedisk_output_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
  91. {
  92. if (drive->bswap) {
  93. idedisk_bswap_data(buffer, wcount);
  94. ide_output_data(drive, buffer, wcount);
  95. idedisk_bswap_data(buffer, wcount);
  96. } else
  97. ide_output_data(drive, buffer, wcount);
  98. }
  100. #endif /* __TASKFILE__IO */
  102. /*
  103.  * lba_capacity_is_ok() performs a sanity check on the claimed "lba_capacity"
  104.  * value for this drive (from its reported identification information).
  105.  *
  106.  * Returns: 1 if lba_capacity looks sensible
  107.  * 0 otherwise
  108.  *
  109.  * It is called only once for each drive.
  110.  */
  111. static int lba_capacity_is_ok (struct hd_driveid *id)
  112. {
  113. unsigned long lba_sects, chs_sects, head, tail;
  115. if ((id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)) {
  116. printk("48-bit Drive: %llu n", id->lba_capacity_2);
  117. return 1;
  118. }
  120. /*
  121.  * The ATA spec tells large drives to return
  122.  * C/H/S = 16383/16/63 independent of their size.
  123.  * Some drives can be jumpered to use 15 heads instead of 16.
  124.  * Some drives can be jumpered to use 4092 cyls instead of 16383.
  125.  */
  126. if ((id->cyls == 16383
  127.      || (id->cyls == 4092 && id->cur_cyls == 16383)) &&
  128.     id->sectors == 63 &&
  129.     (id->heads == 15 || id->heads == 16) &&
  130.     id->lba_capacity >= 16383*63*id->heads)
  131. return 1;
  133. lba_sects   = id->lba_capacity;
  134. chs_sects   = id->cyls * id->heads * id->sectors;
  136. /* perform a rough sanity check on lba_sects:  within 10% is OK */
  137. if ((lba_sects - chs_sects) < chs_sects/10)
  138. return 1;
  140. /* some drives have the word order reversed */
  141. head = ((lba_sects >> 16) & 0xffff);
  142. tail = (lba_sects & 0xffff);
  143. lba_sects = (head | (tail << 16));
  144. if ((lba_sects - chs_sects) < chs_sects/10) {
  145. id->lba_capacity = lba_sects;
  146. return 1; /* lba_capacity is (now) good */
  147. }
  149. return 0; /* lba_capacity value may be bad */
  150. }
  152. #ifndef __TASKFILE__IO
  154. /*
  155.  * read_intr() is the handler for disk read/multread interrupts
  156.  */
  157. static ide_startstop_t read_intr (ide_drive_t *drive)
  158. {
  159. byte stat;
  160. int i;
  161. unsigned int msect, nsect;
  162. unsigned long flags;
  163. struct request *rq;
  164. char *to;
  166. /* new way for dealing with premature shared PCI interrupts */
  167. if (!OK_STAT(stat=GET_STAT(),DATA_READY,BAD_R_STAT)) {
  168. if (stat & (ERR_STAT|DRQ_STAT)) {
  169. return ide_error(drive, "read_intr", stat);
  170. }
  171. /* no data yet, so wait for another interrupt */
  172. ide_set_handler(drive, &read_intr, WAIT_CMD, NULL);
  173. return ide_started;
  174. }
  176. msect = drive->mult_count;
  177. read_next:
  178. rq = HWGROUP(drive)->rq;
  179. if (msect) {
  180. if ((nsect = rq->current_nr_sectors) > msect)
  181. nsect = msect;
  182. msect -= nsect;
  183. } else
  184. nsect = 1;
  185. to = ide_map_buffer(rq, &flags);
  186. idedisk_input_data(drive, to, nsect * SECTOR_WORDS);
  187. #ifdef DEBUG
  188. printk("%s:  read: sectors(%ld-%ld), buffer=0x%08lx, remaining=%ldn",
  189. drive->name, rq->sector, rq->sector+nsect-1,
  190. (unsigned long) rq->buffer+(nsect<<9), rq->nr_sectors-nsect);
  191. #endif
  192. ide_unmap_buffer(to, &flags);
  193. rq->sector += nsect;
  194. rq->errors = 0;
  195. i = (rq->nr_sectors -= nsect);
  196. if (((long)(rq->current_nr_sectors -= nsect)) <= 0)
  197. ide_end_request(1, HWGROUP(drive));
  198. if (i > 0) {
  199. if (msect)
  200. goto read_next;
  201. ide_set_handler (drive, &read_intr, WAIT_CMD, NULL);
  202.                 return ide_started;
  203. }
  204.         return ide_stopped;
  205. }
  207. /*
  208.  * write_intr() is the handler for disk write interrupts
  209.  */
  210. static ide_startstop_t write_intr (ide_drive_t *drive)
  211. {
  212. byte stat;
  213. int i;
  214. ide_hwgroup_t *hwgroup = HWGROUP(drive);
  215. struct request *rq = hwgroup->rq;
  217. if (!OK_STAT(stat=GET_STAT(),DRIVE_READY,drive->bad_wstat)) {
  218. printk("%s: write_intr error1: nr_sectors=%ld, stat=0x%02xn", drive->name, rq->nr_sectors, stat);
  219.         } else {
  220. #ifdef DEBUG
  221. printk("%s: write: sector %ld, buffer=0x%08lx, remaining=%ldn",
  222. drive->name, rq->sector, (unsigned long) rq->buffer,
  223. rq->nr_sectors-1);
  224. #endif
  225. if ((rq->nr_sectors == 1) ^ ((stat & DRQ_STAT) != 0)) {
  226. rq->sector++;
  227. rq->errors = 0;
  228. i = --rq->nr_sectors;
  229. --rq->current_nr_sectors;
  230. if (((long)rq->current_nr_sectors) <= 0)
  231. ide_end_request(1, hwgroup);
  232. if (i > 0) {
  233. unsigned long flags;
  234. char *to = ide_map_buffer(rq, &flags);
  235. idedisk_output_data (drive, to, SECTOR_WORDS);
  236. ide_unmap_buffer(to, &flags);
  237. ide_set_handler (drive, &write_intr, WAIT_CMD, NULL);
  238.                                 return ide_started;
  239. }
  240.                         return ide_stopped;
  241. }
  242. return ide_stopped; /* the original code did this here (?) */
  243. }
  244. return ide_error(drive, "write_intr", stat);
  245. }
  247. /*
  248.  * ide_multwrite() transfers a block of up to mcount sectors of data
  249.  * to a drive as part of a disk multiple-sector write operation.
  250.  *
  251.  * Returns 0 on success.
  252.  *
  253.  * Note that we may be called from two contexts - the do_rw_disk context
  254.  * and IRQ context. The IRQ can happen any time after we've output the
  255.  * full "mcount" number of sectors, so we must make sure we update the
  256.  * state _before_ we output the final part of the data!
  257.  */
  258. int ide_multwrite (ide_drive_t *drive, unsigned int mcount)
  259. {
  260.   ide_hwgroup_t *hwgroup= HWGROUP(drive);
  261.   struct request *rq = &hwgroup->wrq;
  262.  
  263.    do {
  264.    char *buffer;
  265.    int nsect = rq->current_nr_sectors;
  266. unsigned long flags;
  268. if (nsect > mcount)
  269. nsect = mcount;
  270. mcount -= nsect;
  272. buffer = ide_map_buffer(rq, &flags);
  273. rq->sector += nsect;
  274. rq->nr_sectors -= nsect;
  275. rq->current_nr_sectors -= nsect;
  277. /* Do we move to the next bh after this? */
  278. if (!rq->current_nr_sectors) {
  279. struct buffer_head *bh = rq->bh->b_reqnext;
  281. /* end early early we ran out of requests */
  282. if (!bh) {
  283. mcount = 0;
  284. } else {
  285. rq->bh = bh;
  286. rq->current_nr_sectors = bh->b_size >> 9;
  287. rq->hard_cur_sectors = rq->current_nr_sectors;
  288. }
  289. }
  291. /*
  292.  * Ok, we're all setup for the interrupt
  293.  * re-entering us on the last transfer.
  294.  */
  295. idedisk_output_data(drive, buffer, nsect<<7);
  296. ide_unmap_buffer(buffer, &flags);
  297. } while (mcount);
  299.         return 0;
  300. }
  302. /*
  303.  * multwrite_intr() is the handler for disk multwrite interrupts
  304.  */
  305. static ide_startstop_t multwrite_intr (ide_drive_t *drive)
  306. {
  307. byte stat;
  308. int i;
  309. ide_hwgroup_t *hwgroup = HWGROUP(drive);
  310. struct request *rq = &hwgroup->wrq;
  312. if (OK_STAT(stat=GET_STAT(),DRIVE_READY,drive->bad_wstat)) {
  313. if (stat & DRQ_STAT) {
  314. /*
  315.  * The drive wants data. Remember rq is the copy
  316.  * of the request
  317.  */
  318. if (rq->nr_sectors) {
  319. if (ide_multwrite(drive, drive->mult_count))
  320. return ide_stopped;
  321. ide_set_handler (drive, &multwrite_intr, WAIT_CMD, NULL);
  322. return ide_started;
  323. }
  324. } else {
  325. /*
  326.  * If the copy has all the blocks completed then
  327.  * we can end the original request.
  328.  */
  329. if (!rq->nr_sectors) { /* all done? */
  330. rq = hwgroup->rq;
  331. for (i = rq->nr_sectors; i > 0;){
  332. i -= rq->current_nr_sectors;
  333. ide_end_request(1, hwgroup);
  334. }
  335. return ide_stopped;
  336. }
  337. }
  338. return ide_stopped; /* the original code did this here (?) */
  339. }
  340. return ide_error(drive, "multwrite_intr", stat);
  341. }
  342. #endif /* __TASKFILE__IO */
  344. #ifdef __TASKFILE__IO
  346. static ide_startstop_t chs_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block);
  347. static ide_startstop_t lba_28_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block);
  348. static ide_startstop_t lba_48_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long long block);
  350. /*
  351.  * do_rw_disk() issues READ and WRITE commands to a disk,
  352.  * using LBA if supported, or CHS otherwise, to address sectors.
  353.  * It also takes care of issuing special DRIVE_CMDs.
  354.  */
  355. static ide_startstop_t do_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block)
  356. {
  357. if (rq->cmd == READ)
  358. goto good_command;
  359. if (rq->cmd == WRITE)
  360. goto good_command;
  362. printk(KERN_ERR "%s: bad command: %dn", drive->name, rq->cmd);
  363. ide_end_request(0, HWGROUP(drive));
  364. return ide_stopped;
  366. good_command:
  368. #ifdef CONFIG_BLK_DEV_PDC4030
  369. if (IS_PDC4030_DRIVE) {
  370. extern ide_startstop_t promise_rw_disk(ide_drive_t *, struct request *, unsigned long);
  371. return promise_rw_disk(drive, rq, block);
  372. }
  373. #endif /* CONFIG_BLK_DEV_PDC4030 */
  375. if ((drive->id->cfs_enable_2 & 0x0400) && (drive->addressing)) /* 48-bit LBA */
  376. return lba_48_rw_disk(drive, rq, (unsigned long long) block);
  377. if (drive->select.b.lba) /* 28-bit LBA */
  378. return lba_28_rw_disk(drive, rq, (unsigned long) block);
  380. /* 28-bit CHS : DIE DIE DIE piece of legacy crap!!! */
  381. return chs_rw_disk(drive, rq, (unsigned long) block);
  382. }
  384. static task_ioreg_t get_command (ide_drive_t *drive, int cmd)
  385. {
  386. int lba48bit = (drive->id->cfs_enable_2 & 0x0400) ? 1 : 0;
  388. #if 1
  389. lba48bit = drive->addressing;
  390. #endif
  392. if ((cmd == READ) && (drive->using_dma))
  393. return (lba48bit) ? WIN_READDMA_EXT : WIN_READDMA;
  394. else if ((cmd == READ) && (drive->mult_count))
  395. return (lba48bit) ? WIN_MULTREAD_EXT : WIN_MULTREAD;
  396. else if (cmd == READ)
  397. return (lba48bit) ? WIN_READ_EXT : WIN_READ;
  398. else if ((cmd == WRITE) && (drive->using_dma))
  399. return (lba48bit) ? WIN_WRITEDMA_EXT : WIN_WRITEDMA;
  400. else if ((cmd == WRITE) && (drive->mult_count))
  401. return (lba48bit) ? WIN_MULTWRITE_EXT : WIN_MULTWRITE;
  402. else if (cmd == WRITE)
  403. return (lba48bit) ? WIN_WRITE_EXT : WIN_WRITE;
  404. else
  405. return WIN_NOP;
  406. }
  408. static ide_startstop_t chs_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block)
  409. {
  410. struct hd_drive_task_hdr taskfile;
  411. struct hd_drive_hob_hdr hobfile;
  412. ide_task_t args;
  414. task_ioreg_t command = get_command(drive, rq->cmd);
  415. unsigned int track = (block / drive->sect);
  416. unsigned int sect = (block % drive->sect) + 1;
  417. unsigned int head = (track % drive->head);
  418. unsigned int cyl = (track / drive->head);
  420. memset(&taskfile, 0, sizeof(task_struct_t));
  421. memset(&hobfile, 0, sizeof(hob_struct_t));
  423. taskfile.sector_count = (rq->nr_sectors==256)?0x00:rq->nr_sectors;
  424. taskfile.sector_number = sect;
  425. taskfile.low_cylinder = cyl;
  426. taskfile.high_cylinder = (cyl>>8);
  427. taskfile.device_head = head;
  428. taskfile.device_head |= drive->select.all;
  429. taskfile.command = command;
  431. #ifdef DEBUG
  432. printk("%s: %sing: ", drive->name, (rq->cmd==READ) ? "read" : "writ");
  433. if (lba) printk("LBAsect=%lld, ", block);
  434. else printk("CHS=%d/%d/%d, ", cyl, head, sect);
  435. printk("sectors=%ld, ", rq->nr_sectors);
  436. printk("buffer=0x%08lxn", (unsigned long) rq->buffer);
  437. #endif
  439. memcpy(args.tfRegister, &taskfile, sizeof(struct hd_drive_task_hdr));
  440. memcpy(args.hobRegister, &hobfile, sizeof(struct hd_drive_hob_hdr));
  441. args.command_type = ide_cmd_type_parser(&args);
  442. args.prehandler = ide_pre_handler_parser(&taskfile, &hobfile);
  443. args.handler = ide_handler_parser(&taskfile, &hobfile);
  444. args.posthandler = NULL;
  445. args.rq = (struct request *) rq;
  446. args.block = block;
  447. rq->special = NULL;
  448. rq->special = (ide_task_t *)&args;
  450. return do_rw_taskfile(drive, &args);
  451. }
  453. static ide_startstop_t lba_28_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block)
  454. {
  455. struct hd_drive_task_hdr taskfile;
  456. struct hd_drive_hob_hdr hobfile;
  457. ide_task_t args;
  459. task_ioreg_t command = get_command(drive, rq->cmd);
  461. memset(&taskfile, 0, sizeof(task_struct_t));
  462. memset(&hobfile, 0, sizeof(hob_struct_t));
  464. taskfile.sector_count = (rq->nr_sectors==256)?0x00:rq->nr_sectors;
  465. taskfile.sector_number = block;
  466. taskfile.low_cylinder = (block>>=8);
  467. taskfile.high_cylinder = (block>>=8);
  468. taskfile.device_head = ((block>>8)&0x0f);
  469. taskfile.device_head |= drive->select.all;
  470. taskfile.command = command;
  473. #ifdef DEBUG
  474. printk("%s: %sing: ", drive->name, (rq->cmd==READ) ? "read" : "writ");
  475. if (lba) printk("LBAsect=%lld, ", block);
  476. else printk("CHS=%d/%d/%d, ", cyl, head, sect);
  477. printk("sectors=%ld, ", rq->nr_sectors);
  478. printk("buffer=0x%08lxn", (unsigned long) rq->buffer);
  479. #endif
  481. memcpy(args.tfRegister, &taskfile, sizeof(struct hd_drive_task_hdr));
  482. memcpy(args.hobRegister, &hobfile, sizeof(struct hd_drive_hob_hdr));
  483. args.command_type = ide_cmd_type_parser(&args);
  484. args.prehandler = ide_pre_handler_parser(&taskfile, &hobfile);
  485. args.handler = ide_handler_parser(&taskfile, &hobfile);
  486. args.posthandler = NULL;
  487. args.rq = (struct request *) rq;
  488. args.block = block;
  489. rq->special = NULL;
  490. rq->special = (ide_task_t *)&args;
  492. return do_rw_taskfile(drive, &args);
  493. }
  495. /*
  496.  * 268435455  == 137439 MB or 28bit limit
  497.  * 320173056  == 163929 MB or 48bit addressing
  498.  * 1073741822 == 549756 MB or 48bit addressing fake drive
  499.  */
  501. static ide_startstop_t lba_48_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long long block)
  502. {
  503. struct hd_drive_task_hdr taskfile;
  504. struct hd_drive_hob_hdr hobfile;
  505. ide_task_t args;
  507. task_ioreg_t command = get_command(drive, rq->cmd);
  509. memset(&taskfile, 0, sizeof(task_struct_t));
  510. memset(&hobfile, 0, sizeof(hob_struct_t));
  512. taskfile.sector_count = rq->nr_sectors;
  513. hobfile.sector_count = (rq->nr_sectors>>8);
  515. if (rq->nr_sectors == 65536) {
  516. taskfile.sector_count = 0x00;
  517. hobfile.sector_count = 0x00;
  518. }
  520. taskfile.sector_number = block; /* low lba */
  521. taskfile.low_cylinder = (block>>=8); /* mid lba */
  522. taskfile.high_cylinder = (block>>=8); /* hi  lba */
  523. hobfile.sector_number = (block>>=8); /* low lba */
  524. hobfile.low_cylinder = (block>>=8); /* mid lba */
  525. hobfile.high_cylinder = (block>>=8); /* hi  lba */
  526. taskfile.device_head = drive->select.all;
  527. hobfile.device_head = taskfile.device_head;
  528. hobfile.control = (drive->ctl|0x80);
  529. taskfile.command = command;
  531. #ifdef DEBUG
  532. printk("%s: %sing: ", drive->name, (rq->cmd==READ) ? "read" : "writ");
  533. if (lba) printk("LBAsect=%lld, ", block);
  534. else printk("CHS=%d/%d/%d, ", cyl, head, sect);
  535. printk("sectors=%ld, ", rq->nr_sectors);
  536. printk("buffer=0x%08lxn", (unsigned long) rq->buffer);
  537. #endif
  539. memcpy(args.tfRegister, &taskfile, sizeof(struct hd_drive_task_hdr));
  540. memcpy(args.hobRegister, &hobfile, sizeof(struct hd_drive_hob_hdr));
  541. args.command_type = ide_cmd_type_parser(&args);
  542. args.prehandler = ide_pre_handler_parser(&taskfile, &hobfile);
  543. args.handler = ide_handler_parser(&taskfile, &hobfile);
  544. args.posthandler = NULL;
  545. args.rq = (struct request *) rq;
  546. args.block = block;
  547. rq->special = NULL;
  548. rq->special = (ide_task_t *)&args;
  550. return do_rw_taskfile(drive, &args);
  551. }
  553. #else /* !__TASKFILE__IO */
  554. /*
  555.  * do_rw_disk() issues READ and WRITE commands to a disk,
  556.  * using LBA if supported, or CHS otherwise, to address sectors.
  557.  * It also takes care of issuing special DRIVE_CMDs.
  558.  */
  559. static ide_startstop_t do_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block)
  560. {
  561. if (IDE_CONTROL_REG)
  562. OUT_BYTE(drive->ctl,IDE_CONTROL_REG);
  564. #ifdef CONFIG_BLK_DEV_PDC4030
  565. if (drive->select.b.lba || IS_PDC4030_DRIVE) {
  566. #else /* !CONFIG_BLK_DEV_PDC4030 */
  567. if (drive->select.b.lba) {
  568. #endif /* CONFIG_BLK_DEV_PDC4030 */
  570. if ((drive->id->cfs_enable_2 & 0x0400) && (drive->addressing)) {
  571. task_ioreg_t tasklets[10];
  573. tasklets[0] = 0;
  574. tasklets[1] = 0;
  575. tasklets[2] = rq->nr_sectors;
  576. tasklets[3] = (rq->nr_sectors>>8);
  577. if (rq->nr_sectors == 65536) {
  578. tasklets[2] = 0x00;
  579. tasklets[3] = 0x00;
  580. }
  581. tasklets[4] = (task_ioreg_t) block;
  582. tasklets[5] = (task_ioreg_t) (block>>8);
  583. tasklets[6] = (task_ioreg_t) (block>>16);
  584. tasklets[7] = (task_ioreg_t) (block>>24);
  585. tasklets[8] = (task_ioreg_t) 0;
  586. tasklets[9] = (task_ioreg_t) 0;
  587. // tasklets[8] = (task_ioreg_t) (block>>32);
  588. // tasklets[9] = (task_ioreg_t) (block>>40);
  589. #ifdef DEBUG
  590. printk("%s: %sing: LBAsect=%lu, sectors=%ld, buffer=0x%08lx, LBAsect=0x%012lxn",
  591. drive->name,
  592. (rq->cmd==READ)?"read":"writ",
  593. block,
  594. rq->nr_sectors,
  595. (unsigned long) rq->buffer,
  596. block);
  597. printk("%s: 0x%02x%02x 0x%02x%02x%02x%02x%02x%02xn",
  598. drive->name, tasklets[3], tasklets[2],
  599. tasklets[9], tasklets[8], tasklets[7],
  600. tasklets[6], tasklets[5], tasklets[4]);
  601. #endif
  602. OUT_BYTE(tasklets[1], IDE_FEATURE_REG);
  603. OUT_BYTE(tasklets[3], IDE_NSECTOR_REG);
  604. OUT_BYTE(tasklets[7], IDE_SECTOR_REG);
  605. OUT_BYTE(tasklets[8], IDE_LCYL_REG);
  606. OUT_BYTE(tasklets[9], IDE_HCYL_REG);
  608. OUT_BYTE(tasklets[0], IDE_FEATURE_REG);
  609. OUT_BYTE(tasklets[2], IDE_NSECTOR_REG);
  610. OUT_BYTE(tasklets[4], IDE_SECTOR_REG);
  611. OUT_BYTE(tasklets[5], IDE_LCYL_REG);
  612. OUT_BYTE(tasklets[6], IDE_HCYL_REG);
  613. OUT_BYTE(0x00|drive->select.all,IDE_SELECT_REG);
  614. } else {
  615. #ifdef DEBUG
  616. printk("%s: %sing: LBAsect=%ld, sectors=%ld, buffer=0x%08lxn",
  617. drive->name, (rq->cmd==READ)?"read":"writ",
  618. block, rq->nr_sectors, (unsigned long) rq->buffer);
  619. #endif
  620. OUT_BYTE(0x00, IDE_FEATURE_REG);
  621. OUT_BYTE((rq->nr_sectors==256)?0x00:rq->nr_sectors,IDE_NSECTOR_REG);
  622. OUT_BYTE(block,IDE_SECTOR_REG);
  623. OUT_BYTE(block>>=8,IDE_LCYL_REG);
  624. OUT_BYTE(block>>=8,IDE_HCYL_REG);
  625. OUT_BYTE(((block>>8)&0x0f)|drive->select.all,IDE_SELECT_REG);
  626. }
  627. } else {
  628. unsigned int sect,head,cyl,track;
  629. track = block / drive->sect;
  630. sect  = block % drive->sect + 1;
  631. OUT_BYTE(sect,IDE_SECTOR_REG);
  632. head  = track % drive->head;
  633. cyl   = track / drive->head;
  635. OUT_BYTE(0x00, IDE_FEATURE_REG);
  636. OUT_BYTE((rq->nr_sectors==256)?0x00:rq->nr_sectors,IDE_NSECTOR_REG);
  637. OUT_BYTE(cyl,IDE_LCYL_REG);
  638. OUT_BYTE(cyl>>8,IDE_HCYL_REG);
  639. OUT_BYTE(head|drive->select.all,IDE_SELECT_REG);
  640. #ifdef DEBUG
  641. printk("%s: %sing: CHS=%d/%d/%d, sectors=%ld, buffer=0x%08lxn",
  642. drive->name, (rq->cmd==READ)?"read":"writ", cyl,
  643. head, sect, rq->nr_sectors, (unsigned long) rq->buffer);
  644. #endif
  645. }
  646. #ifdef CONFIG_BLK_DEV_PDC4030
  647. if (IS_PDC4030_DRIVE) {
  648. extern ide_startstop_t do_pdc4030_io(ide_drive_t *, struct request *);
  649. return do_pdc4030_io (drive, rq);
  650. }
  651. #endif /* CONFIG_BLK_DEV_PDC4030 */
  652. if (rq->cmd == READ) {
  653. #ifdef CONFIG_BLK_DEV_IDEDMA
  654. if (drive->using_dma && !(HWIF(drive)->dmaproc(ide_dma_read, drive)))
  655. return ide_started;
  656. #endif /* CONFIG_BLK_DEV_IDEDMA */
  657. ide_set_handler(drive, &read_intr, WAIT_CMD, NULL);
  658. if ((drive->id->cfs_enable_2 & 0x0400) && (drive->addressing)) {
  659. OUT_BYTE(drive->mult_count ? WIN_MULTREAD_EXT : WIN_READ_EXT, IDE_COMMAND_REG);
  660. } else {
  661. OUT_BYTE(drive->mult_count ? WIN_MULTREAD : WIN_READ, IDE_COMMAND_REG);
  662. }
  663. return ide_started;
  664. }
  665. if (rq->cmd == WRITE) {
  666. ide_startstop_t startstop;
  667. #ifdef CONFIG_BLK_DEV_IDEDMA
  668. if (drive->using_dma && !(HWIF(drive)->dmaproc(ide_dma_write, drive)))
  669. return ide_started;
  670. #endif /* CONFIG_BLK_DEV_IDEDMA */
  671. if ((drive->id->cfs_enable_2 & 0x0400) && (drive->addressing)) {
  672. OUT_BYTE(drive->mult_count ? WIN_MULTWRITE_EXT : WIN_WRITE_EXT, IDE_COMMAND_REG);
  673. } else {
  674. OUT_BYTE(drive->mult_count ? WIN_MULTWRITE : WIN_WRITE, IDE_COMMAND_REG);
  675. }
  676. if (ide_wait_stat(&startstop, drive, DATA_READY, drive->bad_wstat, WAIT_DRQ)) {
  677. printk(KERN_ERR "%s: no DRQ after issuing %sn", drive->name,
  678. drive->mult_count ? "MULTWRITE" : "WRITE");
  679. return startstop;
  680. }
  681. if (!drive->unmask)
  682. __cli(); /* local CPU only */
  683. if (drive->mult_count) {
  684. ide_hwgroup_t *hwgroup = HWGROUP(drive);
  685. /*
  686.  * Ugh.. this part looks ugly because we MUST set up
  687.  * the interrupt handler before outputting the first block
  688.  * of data to be written.  If we hit an error (corrupted buffer list)
  689.  * in ide_multwrite(), then we need to remove the handler/timer
  690.  * before returning.  Fortunately, this NEVER happens (right?).
  691.  *
  692.  * Except when you get an error it seems...
  693.  */
  694. hwgroup->wrq = *rq; /* scratchpad */
  695. ide_set_handler(drive, &multwrite_intr, WAIT_CMD, NULL);
  696. if (ide_multwrite(drive, drive->mult_count)) {
  697. unsigned long flags;
  698. spin_lock_irqsave(&io_request_lock, flags);
  699. hwgroup->handler = NULL;
  700. del_timer(&hwgroup->timer);
  701. spin_unlock_irqrestore(&io_request_lock, flags);
  702. return ide_stopped;
  703. }
  704. } else {
  705. unsigned long flags;
  706. char *buffer = ide_map_buffer(rq, &flags);
  707. ide_set_handler (drive, &write_intr, WAIT_CMD, NULL);
  708. idedisk_output_data(drive, buffer, SECTOR_WORDS);
  709. ide_unmap_buffer(buffer, &flags);
  710. }
  711. return ide_started;
  712. }
  713. printk(KERN_ERR "%s: bad command: %dn", drive->name, rq->cmd);
  714. ide_end_request(0, HWGROUP(drive));
  715. return ide_stopped;
  716. }
  718. #endif /* __TASKFILE__IO */
  720. static int idedisk_open (struct inode *inode, struct file *filp, ide_drive_t *drive)
  721. {
  722. MOD_INC_USE_COUNT;
  723. if (drive->removable && drive->usage == 1) {
  724. struct hd_drive_task_hdr taskfile;
  725. struct hd_drive_hob_hdr hobfile;
  726. memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
  727. memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
  728. taskfile.command = WIN_DOORLOCK;
  729. check_disk_change(inode->i_rdev);
  730. /*
  731.  * Ignore the return code from door_lock,
  732.  * since the open() has already succeeded,
  733.  * and the door_lock is irrelevant at this point.
  734.  */
  735. if (drive->doorlocking && ide_wait_taskfile(drive, &taskfile, &hobfile, NULL))
  736. drive->doorlocking = 0;
  737. }
  738. return 0;
  739. }
  741. static int do_idedisk_flushcache(ide_drive_t *drive);
  743. static void idedisk_release (struct inode *inode, struct file *filp, ide_drive_t *drive)
  744. {
  745. if (drive->removable && !drive->usage) {
  746. struct hd_drive_task_hdr taskfile;
  747. struct hd_drive_hob_hdr hobfile;
  748. memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
  749. memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
  750. taskfile.command = WIN_DOORUNLOCK;
  751. invalidate_bdev(inode->i_bdev, 0);
  752. if (drive->doorlocking && ide_wait_taskfile(drive, &taskfile, &hobfile, NULL))
  753. drive->doorlocking = 0;
  754. }
  755. if ((drive->id->cfs_enable_2 & 0x3000) && drive->wcache)
  756. if (do_idedisk_flushcache(drive))
  757. printk (KERN_INFO "%s: Write Cache FAILED Flushing!n",
  758. drive->name);
  759. MOD_DEC_USE_COUNT;
  760. }
  762. static int idedisk_media_change (ide_drive_t *drive)
  763. {
  764. return drive->removable; /* if removable, always assume it was changed */
  765. }
  767. static void idedisk_revalidate (ide_drive_t *drive)
  768. {
  769. grok_partitions(HWIF(drive)->gd, drive->select.b.unit,
  770. 1<<PARTN_BITS,
  771. current_capacity(drive));
  772. }
  774. /*
  775.  * Queries for true maximum capacity of the drive.
  776.  * Returns maximum LBA address (> 0) of the drive, 0 if failed.
  777.  */
  778. static unsigned long idedisk_read_native_max_address(ide_drive_t *drive)
  779. {
  780. ide_task_t args;
  781. unsigned long addr = 0;
  783. if (!(drive->id->command_set_1 & 0x0400) &&
  784.     !(drive->id->cfs_enable_2 & 0x0100))
  785. return addr;
  787. /* Create IDE/ATA command request structure */
  788. memset(&args, 0, sizeof(ide_task_t));
  789. args.tfRegister[IDE_SELECT_OFFSET] = 0x40;
  790. args.tfRegister[IDE_COMMAND_OFFSET] = WIN_READ_NATIVE_MAX;
  791. args.handler = task_no_data_intr;
  793. /* submit command request */
  794. ide_raw_taskfile(drive, &args, NULL);
  796. /* if OK, compute maximum address value */
  797. if ((args.tfRegister[IDE_STATUS_OFFSET] & 0x01) == 0) {
  798. addr = ((args.tfRegister[IDE_SELECT_OFFSET] & 0x0f) << 24)
  799.      | ((args.tfRegister[  IDE_HCYL_OFFSET]       ) << 16)
  800.      | ((args.tfRegister[  IDE_LCYL_OFFSET]       ) <<  8)
  801.      | ((args.tfRegister[IDE_SECTOR_OFFSET]       ));
  802. }
  803. addr++; /* since the return value is (maxlba - 1), we add 1 */
  804. return addr;
  805. }
  807. static unsigned long long idedisk_read_native_max_address_ext(ide_drive_t *drive)
  808. {
  809. ide_task_t args;
  810. unsigned long long addr = 0;
  812. /* Create IDE/ATA command request structure */
  813. memset(&args, 0, sizeof(ide_task_t));
  815. args.tfRegister[IDE_SELECT_OFFSET] = 0x40;
  816. args.tfRegister[IDE_COMMAND_OFFSET] = WIN_READ_NATIVE_MAX_EXT;
  817. args.handler = task_no_data_intr;
  819.         /* submit command request */
  820.         ide_raw_taskfile(drive, &args, NULL);
  822. /* if OK, compute maximum address value */
  823. if ((args.tfRegister[IDE_STATUS_OFFSET] & 0x01) == 0) {
  824. u32 high = ((args.hobRegister[IDE_HCYL_OFFSET_HOB])<<16) |
  825.    ((args.hobRegister[IDE_LCYL_OFFSET_HOB])<<8) |
  826.        (args.hobRegister[IDE_SECTOR_OFFSET_HOB]); 
  827. u32 low  = ((args.tfRegister[IDE_HCYL_OFFSET])<<16) |
  828.    ((args.tfRegister[IDE_LCYL_OFFSET])<<8) |
  829.     (args.tfRegister[IDE_SECTOR_OFFSET]);
  830. addr = ((__u64)high << 24) | low;
  831. }
  832. addr++; /* since the return value is (maxlba - 1), we add 1 */
  833. return addr;
  834. }
  836. #ifdef CONFIG_IDEDISK_STROKE
  837. /*
  838.  * Sets maximum virtual LBA address of the drive.
  839.  * Returns new maximum virtual LBA address (> 0) or 0 on failure.
  840.  */
  841. static unsigned long idedisk_set_max_address(ide_drive_t *drive, unsigned long addr_req)
  842. {
  843. ide_task_t args;
  844. unsigned long addr_set = 0;
  846. addr_req--;
  847. /* Create IDE/ATA command request structure */
  848. memset(&args, 0, sizeof(ide_task_t));
  849. args.tfRegister[IDE_SECTOR_OFFSET] = ((addr_req >>  0) & 0xff);
  850. args.tfRegister[IDE_LCYL_OFFSET] = ((addr_req >>  8) & 0xff);
  851. args.tfRegister[IDE_HCYL_OFFSET] = ((addr_req >> 16) & 0xff);
  852. args.tfRegister[IDE_SELECT_OFFSET] = ((addr_req >> 24) & 0x0f) | 0x40;
  853. args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SET_MAX;
  854. args.handler = task_no_data_intr;
  855. /* submit command request */
  856. ide_raw_taskfile(drive, &args, NULL);
  857. /* if OK, read new maximum address value */
  858. if ((args.tfRegister[IDE_STATUS_OFFSET] & 0x01) == 0) {
  859. addr_set = ((args.tfRegister[IDE_SELECT_OFFSET] & 0x0f) << 24)
  860.  | ((args.tfRegister[  IDE_HCYL_OFFSET]       ) << 16)
  861.  | ((args.tfRegister[  IDE_LCYL_OFFSET]       ) <<  8)
  862.  | ((args.tfRegister[IDE_SECTOR_OFFSET]       ));
  863. }
  864. addr_set++;
  865. return addr_set;
  866. }
  868. static unsigned long long idedisk_set_max_address_ext(ide_drive_t *drive, unsigned long long addr_req)
  869. {
  870. ide_task_t args;
  871. unsigned long long addr_set = 0;
  873. addr_req--;
  874. /* Create IDE/ATA command request structure */
  875. memset(&args, 0, sizeof(ide_task_t));
  876. args.tfRegister[IDE_SECTOR_OFFSET] = ((addr_req >>  0) & 0xff);
  877. args.tfRegister[IDE_LCYL_OFFSET] = ((addr_req >>= 8) & 0xff);
  878. args.tfRegister[IDE_HCYL_OFFSET] = ((addr_req >>= 8) & 0xff);
  879. args.tfRegister[IDE_SELECT_OFFSET]      = 0x40;
  880. args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SET_MAX_EXT;
  881. args.hobRegister[IDE_SECTOR_OFFSET_HOB] = ((addr_req >>= 8) & 0xff);
  882. args.hobRegister[IDE_LCYL_OFFSET_HOB] = ((addr_req >>= 8) & 0xff);
  883. args.hobRegister[IDE_HCYL_OFFSET_HOB] = ((addr_req >>= 8) & 0xff);
  884. args.hobRegister[IDE_SELECT_OFFSET_HOB] = 0x40;
  885. args.hobRegister[IDE_CONTROL_OFFSET_HOB]= (drive->ctl|0x80);
  886.         args.handler = task_no_data_intr;
  887. /* submit command request */
  888. ide_raw_taskfile(drive, &args, NULL);
  889. /* if OK, compute maximum address value */
  890. if ((args.tfRegister[IDE_STATUS_OFFSET] & 0x01) == 0) {
  891. u32 high = ((args.hobRegister[IDE_HCYL_OFFSET_HOB])<<16) |
  892.    ((args.hobRegister[IDE_LCYL_OFFSET_HOB])<<8) |
  893.     (args.hobRegister[IDE_SECTOR_OFFSET_HOB]);
  894. u32 low  = ((args.tfRegister[IDE_HCYL_OFFSET])<<16) |
  895.    ((args.tfRegister[IDE_LCYL_OFFSET])<<8) |
  896.     (args.tfRegister[IDE_SECTOR_OFFSET]);
  897. addr_set = ((__u64)high << 24) | low;
  898. }
  899. return addr_set;
  900. }
  902. /*
  903.  * Tests if the drive supports Host Protected Area feature.
  904.  * Returns true if supported, false otherwise.
  905.  */
  906. static inline int idedisk_supports_host_protected_area(ide_drive_t *drive)
  907. {
  908. int flag = (drive->id->cfs_enable_1 & 0x0400) ? 1 : 0;
  909. printk("%s: host protected area => %dn", drive->name, flag);
  910. return flag;
  911. }
  913. #endif /* CONFIG_IDEDISK_STROKE */
  915. /*
  916.  * Compute drive->capacity, the full capacity of the drive
  917.  * Called with drive->id != NULL.
  918.  *
  919.  * To compute capacity, this uses either of
  920.  *
  921.  *    1. CHS value set by user       (whatever user sets will be trusted)
  922.  *    2. LBA value from target drive (require new ATA feature)
  923.  *    3. LBA value from system BIOS  (new one is OK, old one may break)
  924.  *    4. CHS value from system BIOS  (traditional style)
  925.  *
  926.  * in above order (i.e., if value of higher priority is available,
  927.  * reset will be ignored).
  928.  */
  929. static void init_idedisk_capacity (ide_drive_t  *drive)
  930. {
  931. struct hd_driveid *id = drive->id;
  932. unsigned long capacity = drive->cyl * drive->head * drive->sect;
  933. unsigned long set_max = idedisk_read_native_max_address(drive);
  934. unsigned long long capacity_2 = capacity;
  935. unsigned long long set_max_ext;
  937. drive->capacity48 = 0;
  938. drive->select.b.lba = 0;
  940. if (id->cfs_enable_2 & 0x0400) {
  941. capacity_2 = id->lba_capacity_2;
  942. drive->head = drive->bios_head = 255;
  943. drive->sect = drive->bios_sect = 63;
  944. drive->cyl = (unsigned int) capacity_2 / (drive->head * drive->sect);
  945. drive->select.b.lba = 1;
  946. set_max_ext = idedisk_read_native_max_address_ext(drive);
  947. if (set_max_ext > capacity_2) {
  948. #ifdef CONFIG_IDEDISK_STROKE
  949. set_max_ext = idedisk_read_native_max_address_ext(drive);
  950. set_max_ext = idedisk_set_max_address_ext(drive, set_max_ext);
  951. if (set_max_ext) {
  952. drive->capacity48 = capacity_2 = set_max_ext;
  953. drive->cyl = (unsigned int) set_max_ext / (drive->head * drive->sect);
  954. drive->select.b.lba = 1;
  955. drive->id->lba_capacity_2 = capacity_2;
  956.                         }
  957. #else /* !CONFIG_IDEDISK_STROKE */
  958. printk("%s: setmax_ext LBA %llu, native  %llun",
  959. drive->name, set_max_ext, capacity_2);
  960. #endif /* CONFIG_IDEDISK_STROKE */
  961. }
  962. drive->bios_cyl = drive->cyl;
  963. drive->capacity48 = capacity_2;
  964. drive->capacity = (unsigned long) capacity_2;
  965. return;
  966. /* Determine capacity, and use LBA if the drive properly supports it */
  967. } else if ((id->capability & 2) && lba_capacity_is_ok(id)) {
  968. capacity = id->lba_capacity;
  969. drive->cyl = capacity / (drive->head * drive->sect);
  970. drive->select.b.lba = 1;
  971. }
  973. if (set_max > capacity) {
  974. #ifdef CONFIG_IDEDISK_STROKE
  975. set_max = idedisk_read_native_max_address(drive);
  976. set_max = idedisk_set_max_address(drive, set_max);
  977. if (set_max) {
  978. drive->capacity = capacity = set_max;
  979. drive->cyl = set_max / (drive->head * drive->sect);
  980. drive->select.b.lba = 1;
  981. drive->id->lba_capacity = capacity;
  982. }
  983. #else /* !CONFIG_IDEDISK_STROKE */
  984. printk("%s: setmax LBA %lu, native  %lun",
  985. drive->name, set_max, capacity);
  986. #endif /* CONFIG_IDEDISK_STROKE */
  987. }
  989. drive->capacity = capacity;
  991. if ((id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)) {
  992.                 drive->capacity48 = id->lba_capacity_2;
  993. drive->head = 255;
  994. drive->sect = 63;
  995. drive->cyl = (unsigned long)(drive->capacity48) / (drive->head * drive->sect);
  996. }
  997. }
  999. static unsigned long idedisk_capacity (ide_drive_t *drive)
  1000. {
  1001. if (drive->id->cfs_enable_2 & 0x0400)
  1002. return (drive->capacity48 - drive->sect0);
  1003. return (drive->capacity - drive->sect0);
  1004. }
  1006. static ide_startstop_t idedisk_special (ide_drive_t *drive)
  1007. {
  1008. special_t *s = &drive->special;
  1010. if (s->b.set_geometry) {
  1011. struct hd_drive_task_hdr taskfile;
  1012. struct hd_drive_hob_hdr hobfile;
  1013. ide_handler_t *handler = NULL;
  1015. memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
  1016. memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
  1018. s->b.set_geometry = 0;
  1019. taskfile.sector_number = drive->sect;
  1020. taskfile.low_cylinder = drive->cyl;
  1021. taskfile.high_cylinder = drive->cyl>>8;
  1022. taskfile.device_head = ((drive->head-1)|drive->select.all)&0xBF;
  1023. if (!IS_PDC4030_DRIVE) {
  1024. taskfile.sector_count = drive->sect;
  1025. taskfile.command = WIN_SPECIFY;
  1026. handler = ide_handler_parser(&taskfile, &hobfile);
  1027. }
  1028. do_taskfile(drive, &taskfile, &hobfile, handler);
  1029. } else if (s->b.recalibrate) {
  1030. s->b.recalibrate = 0;
  1031. if (!IS_PDC4030_DRIVE) {
  1032. struct hd_drive_task_hdr taskfile;
  1033. struct hd_drive_hob_hdr hobfile;
  1034. memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
  1035. memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
  1036. taskfile.sector_count = drive->sect;
  1037. taskfile.command = WIN_RESTORE;
  1038. do_taskfile(drive, &taskfile, &hobfile, ide_handler_parser(&taskfile, &hobfile));
  1039. }
  1040. } else if (s->b.set_multmode) {
  1041. s->b.set_multmode = 0;
  1042. if (drive->id && drive->mult_req > drive->id->max_multsect)
  1043. drive->mult_req = drive->id->max_multsect;
  1044. if (!IS_PDC4030_DRIVE) {
  1045. struct hd_drive_task_hdr taskfile;
  1046. struct hd_drive_hob_hdr hobfile;
  1047. memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
  1048. memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
  1049. taskfile.sector_count = drive->mult_req;
  1050. taskfile.command = WIN_SETMULT;
  1051. do_taskfile(drive, &taskfile, &hobfile, ide_handler_parser(&taskfile, &hobfile));
  1052. }
  1053. } else if (s->all) {
  1054. int special = s->all;
  1055. s->all = 0;
  1056. printk(KERN_ERR "%s: bad special flag: 0x%02xn", drive->name, special);
  1057. return ide_stopped;
  1058. }
  1059. return IS_PDC4030_DRIVE ? ide_stopped : ide_started;
  1060. }
  1062. static void idedisk_pre_reset (ide_drive_t *drive)
  1063. {
  1064. int legacy = (drive->id->cfs_enable_2 & 0x0400) ? 0 : 1;
  1066. drive->special.all = 0;
  1067. drive->special.b.set_geometry = legacy;
  1068. drive->special.b.recalibrate  = legacy;
  1069. if (OK_TO_RESET_CONTROLLER)
  1070. drive->mult_count = 0;
  1071. if (!drive->keep_settings && !drive->using_dma)
  1072. drive->mult_req = 0;
  1073. if (drive->mult_req != drive->mult_count)
  1074. drive->special.b.set_multmode = 1;
  1075. }
  1077. #ifdef CONFIG_PROC_FS
  1079. static int smart_enable(ide_drive_t *drive)
  1080. {
  1081. struct hd_drive_task_hdr taskfile;
  1082. struct hd_drive_hob_hdr hobfile;
  1083. memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
  1084. memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
  1085. taskfile.feature = SMART_ENABLE;
  1086. taskfile.low_cylinder = SMART_LCYL_PASS;
  1087. taskfile.high_cylinder = SMART_HCYL_PASS;
  1088. taskfile.command = WIN_SMART;
  1089. return ide_wait_taskfile(drive, &taskfile, &hobfile, NULL);
  1090. }
  1092. static int get_smart_values(ide_drive_t *drive, byte *buf)
  1093. {
  1094. struct hd_drive_task_hdr taskfile;
  1095. struct hd_drive_hob_hdr hobfile;
  1096. memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
  1097. memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
  1098. taskfile.feature = SMART_READ_VALUES;
  1099. taskfile.sector_count = 0x01;
  1100. taskfile.low_cylinder = SMART_LCYL_PASS;
  1101. taskfile.high_cylinder = SMART_HCYL_PASS;
  1102. taskfile.command = WIN_SMART;
  1103. (void) smart_enable(drive);
  1104. return ide_wait_taskfile(drive, &taskfile, &hobfile, buf);
  1105. }
  1107. static int get_smart_thresholds(ide_drive_t *drive, byte *buf)
  1108. {
  1109. struct hd_drive_task_hdr taskfile;
  1110. struct hd_drive_hob_hdr hobfile;
  1111. memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
  1112. memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
  1113. taskfile.feature = SMART_READ_THRESHOLDS;
  1114. taskfile.sector_count = 0x01;
  1115. taskfile.low_cylinder = SMART_LCYL_PASS;
  1116. taskfile.high_cylinder = SMART_HCYL_PASS;
  1117. taskfile.command = WIN_SMART;
  1118. (void) smart_enable(drive);
  1119. return ide_wait_taskfile(drive, &taskfile, &hobfile, buf);
  1120. }
  1122. static int proc_idedisk_read_cache
  1123. (char *page, char **start, off_t off, int count, int *eof, void *data)
  1124. {
  1125. ide_drive_t *drive = (ide_drive_t *) data;
  1126. char *out = page;
  1127. int len;
  1129. if (drive->id)
  1130. len = sprintf(out,"%in", drive->id->buf_size / 2);
  1131. else
  1132. len = sprintf(out,"(none)n");
  1133. PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
  1134. }
  1136. static int proc_idedisk_read_smart_thresholds
  1137. (char *page, char **start, off_t off, int count, int *eof, void *data)
  1138. {
  1139. ide_drive_t *drive = (ide_drive_t *)data;
  1140. int len = 0, i = 0;
  1142. if (!get_smart_thresholds(drive, page)) {
  1143. unsigned short *val = (unsigned short *) page;
  1144. char *out = ((char *)val) + (SECTOR_WORDS * 4);
  1145. page = out;
  1146. do {
  1147. out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : 'n');
  1148. val += 1;
  1149. } while (i < (SECTOR_WORDS * 2));
  1150. len = out - page;
  1151. }
  1152. PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
  1153. }
  1155. static int proc_idedisk_read_smart_values
  1156. (char *page, char **start, off_t off, int count, int *eof, void *data)
  1157. {
  1158. ide_drive_t *drive = (ide_drive_t *)data;
  1159. int len = 0, i = 0;
  1161. if (!get_smart_values(drive, page)) {
  1162. unsigned short *val = (unsigned short *) page;
  1163. char *out = ((char *)val) + (SECTOR_WORDS * 4);
  1164. page = out;
  1165. do {
  1166. out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : 'n');
  1167. val += 1;
  1168. } while (i < (SECTOR_WORDS * 2));
  1169. len = out - page;
  1170. }
  1171. PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
  1172. }
  1174. static ide_proc_entry_t idedisk_proc[] = {
  1175. { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL },
  1176. { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL },
  1177. { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_smart_values, NULL },
  1178. { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_smart_thresholds, NULL },
  1179. { NULL, 0, NULL, NULL }
  1180. };
  1182. #else
  1184. #define idedisk_proc NULL
  1186. #endif /* CONFIG_PROC_FS */
  1188. static int set_multcount(ide_drive_t *drive, int arg)
  1189. {
  1190. #ifdef __TASKFILE__IO
  1191. struct hd_drive_task_hdr taskfile;
  1192. struct hd_drive_hob_hdr hobfile;
  1194. if (drive->special.b.set_multmode)
  1195. return -EBUSY;
  1197. memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
  1198. memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
  1199. taskfile.sector_count = drive->mult_req;
  1200. taskfile.command = WIN_SETMULT;
  1201. drive->mult_req = arg;
  1202. drive->special.b.set_multmode = 1;
  1203. ide_wait_taskfile(drive, &taskfile, &hobfile, NULL);
  1204. #else /* !__TASKFILE__IO */
  1205. struct request rq;
  1207. if (drive->special.b.set_multmode)
  1208. return -EBUSY;
  1209. ide_init_drive_cmd (&rq);
  1210. rq.cmd = IDE_DRIVE_CMD;
  1211. drive->mult_req = arg;
  1212. drive->special.b.set_multmode = 1;
  1213. (void) ide_do_drive_cmd (drive, &rq, ide_wait);
  1214. #endif /* __TASKFILE__IO */
  1215. return (drive->mult_count == arg) ? 0 : -EIO;
  1216. }
  1218. static int set_nowerr(ide_drive_t *drive, int arg)
  1219. {
  1220. if (ide_spin_wait_hwgroup(drive))
  1221. return -EBUSY;
  1222. drive->nowerr = arg;
  1223. drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
  1224. spin_unlock_irq(&io_request_lock);
  1225. return 0;
  1226. }
  1228. static int write_cache (ide_drive_t *drive, int arg)
  1229. {
  1230. struct hd_drive_task_hdr taskfile;
  1231. struct hd_drive_hob_hdr hobfile;
  1232. memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
  1233. memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
  1234. taskfile.feature = (arg) ? SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
  1235. taskfile.command = WIN_SETFEATURES;
  1237. if (!(drive->id->cfs_enable_2 & 0x3000))
  1238. return 1;
  1240. (void) ide_wait_taskfile(drive, &taskfile, &hobfile, NULL);
  1241. drive->wcache = arg;
  1242. return 0;
  1243. }
  1245. static int do_idedisk_standby (ide_drive_t *drive)
  1246. {
  1247. struct hd_drive_task_hdr taskfile;
  1248. struct hd_drive_hob_hdr hobfile;
  1249. memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
  1250. memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
  1251. taskfile.command = WIN_STANDBYNOW1;
  1252. return ide_wait_taskfile(drive, &taskfile, &hobfile, NULL);
  1253. }
  1255. static int do_idedisk_flushcache (ide_drive_t *drive)
  1256. {
  1257. struct hd_drive_task_hdr taskfile;
  1258. struct hd_drive_hob_hdr hobfile;
  1259. memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
  1260. memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
  1261. if (drive->id->cfs_enable_2 & 0x2400) {
  1262. taskfile.command = WIN_FLUSH_CACHE_EXT;
  1263. } else {
  1264. taskfile.command = WIN_FLUSH_CACHE;
  1265. }
  1266. return ide_wait_taskfile(drive, &taskfile, &hobfile, NULL);
  1267. }
  1269. static int set_acoustic (ide_drive_t *drive, int arg)
  1270. {
  1271. struct hd_drive_task_hdr taskfile;
  1272. struct hd_drive_hob_hdr hobfile;
  1273. memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
  1274. memset(&hobfile, 0, sizeof(struct hd_drive_hob_hdr));
  1276. taskfile.feature = (arg)?SETFEATURES_EN_AAM:SETFEATURES_DIS_AAM;
  1277. taskfile.sector_count = arg;
  1279. taskfile.command = WIN_SETFEATURES;
  1280. (void) ide_wait_taskfile(drive, &taskfile, &hobfile, NULL);
  1281. drive->acoustic = arg;
  1282. return 0;
  1283. }
  1285. static int probe_lba_addressing (ide_drive_t *drive, int arg)
  1286. {
  1287. drive->addressing =  0;
  1289. if (!(drive->id->cfs_enable_2 & 0x0400))
  1290.                 return -EIO;
  1292. drive->addressing = arg;
  1293. return 0;
  1294. }
  1296. static int set_lba_addressing (ide_drive_t *drive, int arg)
  1297. {
  1298. return (probe_lba_addressing(drive, arg));
  1299. }
  1301. static void idedisk_add_settings(ide_drive_t *drive)
  1302. {
  1303. struct hd_driveid *id = drive->id;
  1304. int major = HWIF(drive)->major;
  1305. int minor = drive->select.b.unit << PARTN_BITS;
  1307. ide_add_setting(drive, "bios_cyl", SETTING_RW, -1, -1, TYPE_INT, 0, 65535, 1, 1, &drive->bios_cyl, NULL);
  1308. ide_add_setting(drive, "bios_head", SETTING_RW, -1, -1, TYPE_BYTE, 0, 255, 1, 1, &drive->bios_head, NULL);
  1309. ide_add_setting(drive, "bios_sect", SETTING_RW, -1, -1, TYPE_BYTE, 0, 63, 1, 1, &drive->bios_sect, NULL);
  1310. ide_add_setting(drive, "address", SETTING_RW, HDIO_GET_ADDRESS, HDIO_SET_ADDRESS, TYPE_INTA, 0, 2, 1, 1, &drive->addressing, set_lba_addressing);
  1311. ide_add_setting(drive, "bswap", SETTING_READ, -1, -1, TYPE_BYTE, 0, 1, 1, 1, &drive->bswap, NULL);
  1312. ide_add_setting(drive, "multcount", id ? SETTING_RW : SETTING_READ, HDIO_GET_MULTCOUNT, HDIO_SET_MULTCOUNT, TYPE_BYTE, 0, id ? id->max_multsect : 0, 1, 1, &drive->mult_count, set_multcount);
  1313. ide_add_setting(drive, "nowerr", SETTING_RW, HDIO_GET_NOWERR, HDIO_SET_NOWERR, TYPE_BYTE, 0, 1, 1, 1, &drive->nowerr, set_nowerr);
  1314. ide_add_setting(drive, "breada_readahead", SETTING_RW, BLKRAGET, BLKRASET, TYPE_INT, 0, 255, 1, 1, &read_ahead[major], NULL);
  1315. ide_add_setting(drive, "file_readahead", SETTING_RW, BLKFRAGET, BLKFRASET, TYPE_INTA, 0, 4096, PAGE_SIZE, 1024, &max_readahead[major][minor], NULL);
  1316. ide_add_setting(drive, "max_kb_per_request", SETTING_RW, BLKSECTGET, BLKSECTSET, TYPE_INTA, 1, 255, 1, 1, &max_sectors[major][minor], NULL);
  1317. ide_add_setting(drive, "lun", SETTING_RW, -1, -1, TYPE_INT, 0, 7, 1, 1, &drive->lun, NULL);
  1318. ide_add_setting(drive, "wcache", SETTING_RW, HDIO_GET_WCACHE, HDIO_SET_WCACHE, TYPE_BYTE, 0, 1, 1, 1, &drive->wcache, write_cache);
  1319. ide_add_setting(drive, "acoustic", SETTING_RW, HDIO_GET_ACOUSTIC, HDIO_SET_ACOUSTIC, TYPE_BYTE, 0, 254, 1, 1, &drive->acoustic, set_acoustic);
  1320.   ide_add_setting(drive, "failures", SETTING_RW, -1, -1, TYPE_INT, 0, 65535, 1, 1, &drive->failures, NULL);
  1321.   ide_add_setting(drive, "max_failures", SETTING_RW, -1, -1, TYPE_INT, 0, 65535, 1, 1, &drive->max_failures, NULL);
  1322. }
  1324. static void idedisk_setup (ide_drive_t *drive)
  1325. {
  1326. int i;
  1328. struct hd_driveid *id = drive->id;
  1329. unsigned long capacity;
  1331. idedisk_add_settings(drive);
  1333. if (id == NULL)
  1334. return;
  1336. /*
  1337.  * CompactFlash cards and their brethern look just like hard drives
  1338.  * to us, but they are removable and don't have a doorlock mechanism.
  1339.  */
  1340. if (drive->removable && !drive_is_flashcard(drive)) {
  1341. /*
  1342.  * Removable disks (eg. SYQUEST); ignore 'WD' drives 
  1343.  */
  1344. if (id->model[0] != 'W' || id->model[1] != 'D') {
  1345. drive->doorlocking = 1;
  1346. }
  1347. }
  1348. for (i = 0; i < MAX_DRIVES; ++i) {
  1349. ide_hwif_t *hwif = HWIF(drive);
  1351. if (drive != &hwif->drives[i]) continue;
  1352. hwif->gd->de_arr[i] = drive->de;
  1353. if (drive->removable)
  1354. hwif->gd->flags[i] |= GENHD_FL_REMOVABLE;
  1355. break;
  1356. }
  1358. /* Extract geometry if we did not already have one for the drive */
  1359. if (!drive->cyl || !drive->head || !drive->sect) {
  1360. drive->cyl     = drive->bios_cyl  = id->cyls;
  1361. drive->head    = drive->bios_head = id->heads;
  1362. drive->sect    = drive->bios_sect = id->sectors;
  1363. }
  1365. /* Handle logical geometry translation by the drive */
  1366. if ((id->field_valid & 1) && id->cur_cyls &&
  1367.     id->cur_heads && (id->cur_heads <= 16) && id->cur_sectors) {
  1368. drive->cyl  = id->cur_cyls;
  1369. drive->head = id->cur_heads;
  1370. drive->sect = id->cur_sectors;
  1371. }
  1373. /* Use physical geometry if what we have still makes no sense */
  1374. if (drive->head > 16 && id->heads && id->heads <= 16) {
  1375. drive->cyl  = id->cyls;
  1376. drive->head = id->heads;
  1377. drive->sect = id->sectors;
  1378. }
  1380. /* calculate drive capacity, and select LBA if possible */
  1381. init_idedisk_capacity (drive);
  1383. /*
  1384.  * if possible, give fdisk access to more of the drive,
  1385.  * by correcting bios_cyls:
  1386.  */
  1387. capacity = idedisk_capacity (drive);
  1388. if ((capacity >= (drive->bios_cyl * drive->bios_sect * drive->bios_head)) &&
  1389.     (!drive->forced_geom) && drive->bios_sect && drive->bios_head)
  1390. drive->bios_cyl = (capacity / drive->bios_sect) / drive->bios_head;
  1391. printk (KERN_INFO "%s: %ld sectors", drive->name, capacity);
  1393. /* Give size in megabytes (MB), not mebibytes (MiB). */
  1394. /* We compute the exact rounded value, avoiding overflow. */
  1395. printk (" (%ld MB)", (capacity - capacity/625 + 974)/1950);
  1397. /* Only print cache size when it was specified */
  1398. if (id->buf_size)
  1399. printk (" w/%dKiB Cache", id->buf_size/2);
  1401. printk(", CHS=%d/%d/%d", 
  1402.        drive->bios_cyl, drive->bios_head, drive->bios_sect);
  1403. #ifdef CONFIG_BLK_DEV_IDEDMA
  1404. if (drive->using_dma)
  1405. (void) HWIF(drive)->dmaproc(ide_dma_verbose, drive);
  1406. #endif /* CONFIG_BLK_DEV_IDEDMA */
  1407. printk("n");
  1409. drive->mult_count = 0;
  1410. if (id->max_multsect) {
  1411. #ifdef CONFIG_IDEDISK_MULTI_MODE
  1412. id->multsect = ((id->max_multsect/2) > 1) ? id->max_multsect : 0;
  1413. id->multsect_valid = id->multsect ? 1 : 0;
  1414. drive->mult_req = id->multsect_valid ? id->max_multsect : INITIAL_MULT_COUNT;
  1415. drive->special.b.set_multmode = drive->mult_req ? 1 : 0;
  1416. #else /* original, pre IDE-NFG, per request of AC */
  1417. drive->mult_req = INITIAL_MULT_COUNT;
  1418. if (drive->mult_req > id->max_multsect)
  1419. drive->mult_req = id->max_multsect;
  1420. if (drive->mult_req || ((id->multsect_valid & 1) && id->multsect))
  1421. drive->special.b.set_multmode = 1;
  1422. #endif /* CONFIG_IDEDISK_MULTI_MODE */
  1423. }
  1424. drive->no_io_32bit = id->dword_io ? 1 : 0;
  1425. if (drive->id->cfs_enable_2 & 0x3000)
  1426. write_cache(drive, (id->cfs_enable_2 & 0x3000));
  1427. (void) probe_lba_addressing(drive, 1);
  1428. }
  1430. static int idedisk_cleanup (ide_drive_t *drive)
  1431. {
  1432. if ((drive->id->cfs_enable_2 & 0x3000) && drive->wcache)
  1433. if (do_idedisk_flushcache(drive))
  1434. printk (KERN_INFO "%s: Write Cache FAILED Flushing!n",
  1435. drive->name);
  1436. return ide_unregister_subdriver(drive);
  1437. }
  1439. int idedisk_reinit(ide_drive_t *drive);
  1441. /*
  1442.  *      IDE subdriver functions, registered with ide.c
  1443.  */
  1444. static ide_driver_t idedisk_driver = {
  1445. name: "ide-disk",
  1446. version: IDEDISK_VERSION,
  1447. media: ide_disk,
  1448. busy: 0,
  1449. supports_dma: 1,
  1450. supports_dsc_overlap: 0,
  1451. cleanup: idedisk_cleanup,
  1452. standby: do_idedisk_standby,
  1453. flushcache: do_idedisk_flushcache,
  1454. do_request: do_rw_disk,
  1455. end_request: NULL,
  1456. ioctl: NULL,
  1457. open: idedisk_open,
  1458. release: idedisk_release,
  1459. media_change: idedisk_media_change,
  1460. revalidate: idedisk_revalidate,
  1461. pre_reset: idedisk_pre_reset,
  1462. capacity: idedisk_capacity,
  1463. special: idedisk_special,
  1464. proc: idedisk_proc,
  1465. reinit: idedisk_reinit,
  1466. ata_prebuilder: NULL,
  1467. atapi_prebuilder: NULL,
  1468. };
  1470. int idedisk_init (void);
  1471. static ide_module_t idedisk_module = {
  1472. IDE_DRIVER_MODULE,
  1473. idedisk_init,
  1474. &idedisk_driver,
  1475. NULL
  1476. };
  1478. MODULE_DESCRIPTION("ATA DISK Driver");
  1480. int idedisk_reinit (ide_drive_t *drive)
  1481. {
  1482. int failed = 0;
  1484. MOD_INC_USE_COUNT;
  1486. if (ide_register_subdriver (drive, &idedisk_driver, IDE_SUBDRIVER_VERSION)) {
  1487. printk (KERN_ERR "ide-disk: %s: Failed to register the driver with ide.cn", drive->name);
  1488. return 1;
  1489. }
  1490. DRIVER(drive)->busy++;
  1491. idedisk_setup(drive);
  1492. if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
  1493. printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?n", drive->name, drive->head);
  1494. (void) idedisk_cleanup(drive);
  1495. DRIVER(drive)->busy--;
  1496. return 1;
  1497. }
  1498. DRIVER(drive)->busy--;
  1499. failed--;
  1501. ide_register_module(&idedisk_module);
  1502. MOD_DEC_USE_COUNT;
  1503. return 0;
  1504. }
  1506. static void __exit idedisk_exit (void)
  1507. {
  1508. ide_drive_t *drive;
  1509. int failed = 0;
  1511. while ((drive = ide_scan_devices (ide_disk, idedisk_driver.name, &idedisk_driver, failed)) != NULL) {
  1512. if (idedisk_cleanup (drive)) {
  1513. printk (KERN_ERR "%s: cleanup_module() called while still busyn", drive->name);
  1514. failed++;
  1515. }
  1516. /* We must remove proc entries defined in this module.
  1517.    Otherwise we oops while accessing these entries */
  1518. #ifdef CONFIG_PROC_FS
  1519. if (drive->proc)
  1520. ide_remove_proc_entries(drive->proc, idedisk_proc);
  1521. #endif
  1522. }
  1523. ide_unregister_module(&idedisk_module);
  1524. }
  1526. int idedisk_init (void)
  1527. {
  1528. ide_drive_t *drive;
  1529. int failed = 0;
  1531. MOD_INC_USE_COUNT;
  1532. while ((drive = ide_scan_devices (ide_disk, idedisk_driver.name, NULL, failed++)) != NULL) {
  1533. if (ide_register_subdriver (drive, &idedisk_driver, IDE_SUBDRIVER_VERSION)) {
  1534. printk (KERN_ERR "ide-disk: %s: Failed to register the driver with ide.cn", drive->name);
  1535. continue;
  1536. }
  1537. DRIVER(drive)->busy++;
  1538. idedisk_setup(drive);
  1539. if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
  1540. printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?n", drive->name, drive->head);
  1541. (void) idedisk_cleanup(drive);
  1542. DRIVER(drive)->busy--;
  1543. continue;
  1544. }
  1545. DRIVER(drive)->busy--;
  1546. failed--;
  1547. }
  1548. ide_register_module(&idedisk_module);
  1549. MOD_DEC_USE_COUNT;
  1550. return 0;
  1551. }
  1553. module_init(idedisk_init);
  1554. module_exit(idedisk_exit);
  1555. MODULE_LICENSE("GPL");