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

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

Linux/Unix编程

开发平台：

Unix_Linux

ide-floppy.c：源码内容
  1. /*
  2.  * linux/drivers/ide/ide-floppy.c Version 0.99 Feb 24 2002
  3.  *
  4.  * Copyright (C) 1996 - 1999 Gadi Oxman <gadio@netvision.net.il>
  5.  * Copyright (C) 2000 - 2002 Paul Bristow <paul@paulbristow.net>
  6.  */
  8. /*
  9.  * IDE ATAPI floppy driver.
  10.  *
  11.  * The driver currently doesn't have any fancy features, just the bare
  12.  * minimum read/write support.
  13.  *
  14.  * This driver supports the following IDE floppy drives:
  15.  *
  16.  * LS-120/240 SuperDisk
  17.  * Iomega Zip 100/250
  18.  * Iomega PC Card Clik!/PocketZip
  19.  *
  20.  * Many thanks to Lode Leroy <Lode.Leroy@www.ibase.be>, who tested so many
  21.  * ALPHA patches to this driver on an EASYSTOR LS-120 ATAPI floppy drive.
  22.  *
  23.  * Ver 0.1   Oct 17 96   Initial test version, mostly based on ide-tape.c.
  24.  * Ver 0.2   Oct 31 96   Minor changes.
  25.  * Ver 0.3   Dec  2 96   Fixed error recovery bug.
  26.  * Ver 0.4   Jan 26 97   Add support for the HDIO_GETGEO ioctl.
  27.  * Ver 0.5   Feb 21 97   Add partitions support.
  28.  *                       Use the minimum of the LBA and CHS capacities.
  29.  *                       Avoid hwgroup->rq == NULL on the last irq.
  30.  *                       Fix potential null dereferencing with DEBUG_LOG.
  31.  * Ver 0.8   Dec  7 97   Increase irq timeout from 10 to 50 seconds.
  32.  *                       Add media write-protect detection.
  33.  *                       Issue START command only if TEST UNIT READY fails.
  34.  *                       Add work-around for IOMEGA ZIP revision 21.D.
  35.  *                       Remove idefloppy_get_capabilities().
  36.  * Ver 0.9   Jul  4 99   Fix a bug which might have caused the number of
  37.  *                        bytes requested on each interrupt to be zero.
  38.  *                        Thanks to <shanos@es.co.nz> for pointing this out.
  39.  * Ver 0.9.sv Jan 6 01   Sam Varshavchik <mrsam@courier-mta.com>
  40.  *                       Implement low level formatting.  Reimplemented
  41.  *                       IDEFLOPPY_CAPABILITIES_PAGE, since we need the srfp
  42.  *                       bit.  My LS-120 drive barfs on
  43.  *                       IDEFLOPPY_CAPABILITIES_PAGE, but maybe it's just me.
  44.  *                       Compromise by not reporting a failure to get this
  45.  *                       mode page.  Implemented four IOCTLs in order to
  46.  *                       implement formatting.  IOCTls begin with 0x4600,
  47.  *                       0x46 is 'F' as in Format.
  48.  *            Jan 9 01   Userland option to select format verify.
  49.  *                       Added PC_SUPPRESS_ERROR flag - some idefloppy drives
  50.  *                       do not implement IDEFLOPPY_CAPABILITIES_PAGE, and
  51.  *                       return a sense error.  Suppress error reporting in
  52.  *                       this particular case in order to avoid spurious
  53.  *                       errors in syslog.  The culprit is
  54.  *                       idefloppy_get_capability_page(), so move it to
  55.  *                       idefloppy_begin_format() so that it's not used
  56.  *                       unless absolutely necessary.
  57.  *                       If drive does not support format progress indication
  58.  *                       monitor the dsc bit in the status register.
  59.  *                       Also, O_NDELAY on open will allow the device to be
  60.  *                       opened without a disk available.  This can be used to
  61.  *                       open an unformatted disk, or get the device capacity.
  62.  * Ver 0.91  Dec 11 99   Added IOMEGA Clik! drive support by 
  63.  *         <paul@paulbristow.net>
  64.  * Ver 0.92  Oct 22 00   Paul Bristow became official maintainer for this 
  65.  *               driver.  Included Powerbook internal zip kludge.
  66.  * Ver 0.93  Oct 24 00   Fixed bugs for Clik! drive
  67.  *                        no disk on insert and disk change now works
  68.  * Ver 0.94  Oct 27 00   Tidied up to remove strstr(Clik) everywhere
  69.  * Ver 0.95  Nov  7 00   Brought across to kernel 2.4
  70.  * Ver 0.96  Jan  7 01   Actually in line with release version of 2.4.0
  71.  *                       including set_bit patch from Rusty Russell
  72.  * Ver 0.97  Jul 22 01   Merge 0.91-0.96 onto 0.9.sv for ac series
  73.  * Ver 0.97.sv Aug 3 01  Backported from 2.4.7-ac3
  74.  * Ver 0.98  Oct 26 01   Split idefloppy_transfer_pc into two pieces to
  75.  *                        fix a lost interrupt problem. It appears the busy
  76.  *                        bit was being deasserted by my IOMEGA ATAPI ZIP 100
  77.  *                        drive before the drive was actually ready.
  78.  * Ver 0.98a Oct 29 01   Expose delay value so we can play.
  79.  * Ver 0.99  Feb 24 02   Remove duplicate code, modify clik! detection code 
  80.  *                        to support new PocketZip drives 
  81.  */
  83. #define IDEFLOPPY_VERSION "0.99.newide"
  85. #include <linux/config.h>
  86. #include <linux/module.h>
  87. #include <linux/types.h>
  88. #include <linux/string.h>
  89. #include <linux/kernel.h>
  90. #include <linux/delay.h>
  91. #include <linux/timer.h>
  92. #include <linux/mm.h>
  93. #include <linux/interrupt.h>
  94. #include <linux/major.h>
  95. #include <linux/errno.h>
  96. #include <linux/genhd.h>
  97. #include <linux/slab.h>
  98. #include <linux/cdrom.h>
  99. #include <linux/ide.h>
  101. #include <asm/byteorder.h>
  102. #include <asm/irq.h>
  103. #include <asm/uaccess.h>
  104. #include <asm/io.h>
  105. #include <asm/unaligned.h>
  106. #include <asm/bitops.h>
  108. /*
  109.  * The following are used to debug the driver.
  110.  */
  111. #define IDEFLOPPY_DEBUG_LOG 0
  112. #define IDEFLOPPY_DEBUG_INFO 0
  113. #define IDEFLOPPY_DEBUG_BUGS 1
  115. /* #define IDEFLOPPY_DEBUG(fmt, args...) printk(KERN_INFO fmt, ## args) */
  116. #define IDEFLOPPY_DEBUG( fmt, args... )
  119. /*
  120.  * Some drives require a longer irq timeout.
  121.  */
  122. #define IDEFLOPPY_WAIT_CMD (5 * WAIT_CMD)
  124. /*
  125.  * After each failed packet command we issue a request sense command
  126.  * and retry the packet command IDEFLOPPY_MAX_PC_RETRIES times.
  127.  */
  128. #define IDEFLOPPY_MAX_PC_RETRIES 3
  130. /*
  131.  * With each packet command, we allocate a buffer of
  132.  * IDEFLOPPY_PC_BUFFER_SIZE bytes.
  133.  */
  134. #define IDEFLOPPY_PC_BUFFER_SIZE 256
  136. /*
  137.  * In various places in the driver, we need to allocate storage
  138.  * for packet commands and requests, which will remain valid while
  139.  * we leave the driver to wait for an interrupt or a timeout event.
  140.  */
  141. #define IDEFLOPPY_PC_STACK (10 + IDEFLOPPY_MAX_PC_RETRIES)
  143. /*
  144.  * Our view of a packet command.
  145.  */
  146. typedef struct idefloppy_packet_command_s {
  147. u8 c[12]; /* Actual packet bytes */
  148. int retries; /* On each retry, we increment retries */
  149. int error; /* Error code */
  150. int request_transfer; /* Bytes to transfer */
  151. int actually_transferred; /* Bytes actually transferred */
  152. int buffer_size; /* Size of our data buffer */
  153. char *b_data; /* Pointer which runs on the buffers */
  154. int b_count; /* Missing/Available data on the current buffer */
  155. struct request *rq; /* The corresponding request */
  156. byte *buffer; /* Data buffer */
  157. byte *current_position; /* Pointer into the above buffer */
  158. void (*callback) (ide_drive_t *); /* Called when this packet command is completed */
  159. byte pc_buffer[IDEFLOPPY_PC_BUFFER_SIZE]; /* Temporary buffer */
  160. unsigned long flags; /* Status/Action bit flags: long for set_bit */
  161. } idefloppy_pc_t;
  163. /*
  164.  * Packet command flag bits.
  165.  */
  166. #define PC_ABORT 0 /* Set when an error is considered normal - We won't retry */
  167. #define PC_DMA_RECOMMENDED 2 /* 1 when we prefer to use DMA if possible */
  168. #define PC_DMA_IN_PROGRESS 3 /* 1 while DMA in progress */
  169. #define PC_DMA_ERROR 4 /* 1 when encountered problem during DMA */
  170. #define PC_WRITING 5 /* Data direction */
  172. #define PC_SUPPRESS_ERROR 6 /* Suppress error reporting */
  174. /*
  175.  * Removable Block Access Capabilities Page
  176.  */
  177. typedef struct {
  178. #if defined(__LITTLE_ENDIAN_BITFIELD)
  179. unsigned page_code :6; /* Page code - Should be 0x1b */
  180. unsigned reserved1_6 :1; /* Reserved */
  181. unsigned ps :1; /* Should be 0 */
  182. #elif defined(__BIG_ENDIAN_BITFIELD)
  183. unsigned ps :1; /* Should be 0 */
  184. unsigned reserved1_6 :1; /* Reserved */
  185. unsigned page_code :6; /* Page code - Should be 0x1b */
  186. #else
  187. #error "Bitfield endianness not defined! Check your byteorder.h"
  188. #endif
  189. u8 page_length; /* Page Length - Should be 0xa */
  190. #if defined(__LITTLE_ENDIAN_BITFIELD)
  191. unsigned reserved2 :6;
  192. unsigned srfp :1; /* Supports reporting progress of format */
  193. unsigned sflp :1; /* System floppy type device */
  194. unsigned tlun :3; /* Total logical units supported by the device */
  195. unsigned reserved3 :3;
  196. unsigned sml :1; /* Single / Multiple lun supported */
  197. unsigned ncd :1; /* Non cd optical device */
  198. #elif defined(__BIG_ENDIAN_BITFIELD)
  199. unsigned sflp :1; /* System floppy type device */
  200. unsigned srfp :1; /* Supports reporting progress of format */
  201. unsigned reserved2 :6;
  202. unsigned ncd :1; /* Non cd optical device */
  203. unsigned sml :1; /* Single / Multiple lun supported */
  204. unsigned reserved3 :3;
  205. unsigned tlun :3; /* Total logical units supported by the device */
  206. #else
  207. #error "Bitfield endianness not defined! Check your byteorder.h"
  208. #endif
  209. u8 reserved[8];
  210. } idefloppy_capabilities_page_t;
  212. /*
  213.  * Flexible disk page.
  214.  */
  215. typedef struct {
  216. #if defined(__LITTLE_ENDIAN_BITFIELD)
  217. unsigned page_code :6; /* Page code - Should be 0x5 */
  218. unsigned reserved1_6 :1; /* Reserved */
  219. unsigned ps :1; /* The device is capable of saving the page */
  220. #elif defined(__BIG_ENDIAN_BITFIELD)
  221. unsigned ps :1; /* The device is capable of saving the page */
  222. unsigned reserved1_6 :1; /* Reserved */
  223. unsigned page_code :6; /* Page code - Should be 0x5 */
  224. #else
  225. #error "Bitfield endianness not defined! Check your byteorder.h"
  226. #endif
  227. u8 page_length; /* Page Length - Should be 0x1e */
  228. u16 transfer_rate; /* In kilobits per second */
  229. u8 heads, sectors; /* Number of heads, Number of sectors per track */
  230. u16 sector_size; /* Byes per sector */
  231. u16 cyls; /* Number of cylinders */
  232. u8 reserved10[10];
  233. u8 motor_delay; /* Motor off delay */
  234. u8 reserved21[7];
  235. u16 rpm; /* Rotations per minute */
  236. u8 reserved30[2];
  237. } idefloppy_flexible_disk_page_t;
  238.  
  239. /*
  240.  * Format capacity
  241.  */
  242. typedef struct {
  243. u8 reserved[3];
  244. u8 length; /* Length of the following descriptors in bytes */
  245. } idefloppy_capacity_header_t;
  247. typedef struct {
  248. u32 blocks; /* Number of blocks */
  249. #if defined(__LITTLE_ENDIAN_BITFIELD)
  250. unsigned dc :2; /* Descriptor Code */
  251. unsigned reserved :6;
  252. #elif defined(__BIG_ENDIAN_BITFIELD)
  253. unsigned reserved :6;
  254. unsigned dc :2; /* Descriptor Code */
  255. #else
  256. #error "Bitfield endianness not defined! Check your byteorder.h"
  257. #endif
  258. u8 length_msb; /* Block Length (MSB)*/
  259. u16 length; /* Block Length */
  260. } idefloppy_capacity_descriptor_t;
  262. #define CAPACITY_INVALID 0x00
  263. #define CAPACITY_UNFORMATTED 0x01
  264. #define CAPACITY_CURRENT 0x02
  265. #define CAPACITY_NO_CARTRIDGE 0x03
  267. /*
  268.  * Most of our global data which we need to save even as we leave the
  269.  * driver due to an interrupt or a timer event is stored in a variable
  270.  * of type idefloppy_floppy_t, defined below.
  271.  */
  272. typedef struct {
  273. ide_drive_t *drive;
  275. idefloppy_pc_t *pc; /* Current packet command */
  276. idefloppy_pc_t *failed_pc;  /* Last failed packet command */
  277. idefloppy_pc_t pc_stack[IDEFLOPPY_PC_STACK];/* Packet command stack */
  278. int pc_stack_index; /* Next free packet command storage space */
  279. struct request rq_stack[IDEFLOPPY_PC_STACK];
  280. int rq_stack_index; /* We implement a circular array */
  282. /*
  283.  * Last error information
  284.  */
  285. byte sense_key, asc, ascq;
  286. byte ticks; /* delay this long before sending packet command */
  287. int progress_indication;
  289. /*
  290.  * Device information
  291.  */
  292. int blocks, block_size, bs_factor; /* Current format */
  293. idefloppy_capacity_descriptor_t capacity; /* Last format capacity */
  294. idefloppy_flexible_disk_page_t flexible_disk_page; /* Copy of the flexible disk page */
  295. int wp; /* Write protect */
  296. int srfp; /* Supports format progress report */
  297. unsigned long flags; /* Status/Action flags */
  298. } idefloppy_floppy_t;
  300. #define IDEFLOPPY_TICKS_DELAY 3 /* default delay for ZIP 100 */
  302. /*
  303.  * Floppy flag bits values.
  304.  */
  305. #define IDEFLOPPY_DRQ_INTERRUPT 0 /* DRQ interrupt device */
  306. #define IDEFLOPPY_MEDIA_CHANGED 1 /* Media may have changed */
  307. #define IDEFLOPPY_USE_READ12 2 /* Use READ12/WRITE12 or READ10/WRITE10 */
  308. #define IDEFLOPPY_FORMAT_IN_PROGRESS 3 /* Format in progress */
  309. #define IDEFLOPPY_CLIK_DRIVE         4       /* Avoid commands not supported in Clik drive */
  310. #define IDEFLOPPY_ZIP_DRIVE 5 /* Requires BH algorithm for packets */
  312. /*
  313.  * ATAPI floppy drive packet commands
  314.  */
  315. #define IDEFLOPPY_FORMAT_UNIT_CMD 0x04
  316. #define IDEFLOPPY_INQUIRY_CMD 0x12
  317. #define IDEFLOPPY_MODE_SELECT_CMD 0x55
  318. #define IDEFLOPPY_MODE_SENSE_CMD 0x5a
  319. #define IDEFLOPPY_READ10_CMD 0x28
  320. #define IDEFLOPPY_READ12_CMD 0xa8
  321. #define IDEFLOPPY_READ_CAPACITY_CMD 0x23
  322. #define IDEFLOPPY_REQUEST_SENSE_CMD 0x03
  323. #define IDEFLOPPY_PREVENT_REMOVAL_CMD 0x1e
  324. #define IDEFLOPPY_SEEK_CMD 0x2b
  325. #define IDEFLOPPY_START_STOP_CMD 0x1b
  326. #define IDEFLOPPY_TEST_UNIT_READY_CMD 0x00
  327. #define IDEFLOPPY_VERIFY_CMD 0x2f
  328. #define IDEFLOPPY_WRITE10_CMD 0x2a
  329. #define IDEFLOPPY_WRITE12_CMD 0xaa
  330. #define IDEFLOPPY_WRITE_VERIFY_CMD 0x2e
  332. /*
  333.  * Defines for the mode sense command
  334.  */
  335. #define MODE_SENSE_CURRENT 0x00
  336. #define MODE_SENSE_CHANGEABLE 0x01
  337. #define MODE_SENSE_DEFAULT 0x02 
  338. #define MODE_SENSE_SAVED 0x03
  340. /*
  341.  * IOCTLs used in low-level formatting.
  342.  */
  344. #define IDEFLOPPY_IOCTL_FORMAT_SUPPORTED 0x4600
  345. #define IDEFLOPPY_IOCTL_FORMAT_GET_CAPACITY 0x4601
  346. #define IDEFLOPPY_IOCTL_FORMAT_START 0x4602
  347. #define IDEFLOPPY_IOCTL_FORMAT_GET_PROGRESS 0x4603
  349. /*
  350.  * Special requests for our block device strategy routine.
  351.  */
  352. #define IDEFLOPPY_FIRST_RQ 90
  354. /*
  355.  *  IDEFLOPPY_PC_RQ is used to queue a packet command in the request queue.
  356.  */
  357. #define IDEFLOPPY_PC_RQ 90
  359. #define IDEFLOPPY_LAST_RQ 90
  361. /*
  362.  * A macro which can be used to check if a given request command
  363.  * originated in the driver or in the buffer cache layer.
  364.  */
  365. #define IDEFLOPPY_RQ_CMD(cmd)  ((cmd >= IDEFLOPPY_FIRST_RQ) && (cmd <= IDEFLOPPY_LAST_RQ))
  367. /*
  368.  * Error codes which are returned in rq->errors to the higher part
  369.  * of the driver.
  370.  */
  371. #define IDEFLOPPY_ERROR_GENERAL 101
  373. /*
  374.  * The ATAPI Status Register.
  375.  */
  376. typedef union {
  377. unsigned all :8;
  378. struct {
  379. #if defined(__LITTLE_ENDIAN_BITFIELD)
  380. unsigned check :1; /* Error occurred */
  381. unsigned idx :1; /* Reserved */
  382. unsigned corr :1; /* Correctable error occurred */
  383. unsigned drq :1; /* Data is request by the device */
  384. unsigned dsc :1; /* Media access command finished */
  385. unsigned reserved5 :1; /* Reserved */
  386. unsigned drdy :1; /* Ignored for ATAPI commands (ready to accept ATA command) */
  387. unsigned bsy :1; /* The device has access to the command block */
  388. #elif defined(__BIG_ENDIAN_BITFIELD)
  389. unsigned bsy :1; /* The device has access to the command block */
  390. unsigned drdy :1; /* Ignored for ATAPI commands (ready to accept ATA command) */
  391. unsigned reserved5 :1; /* Reserved */
  392. unsigned dsc :1; /* Media access command finished */
  393. unsigned drq :1; /* Data is request by the device */
  394. unsigned corr :1; /* Correctable error occurred */
  395. unsigned idx :1; /* Reserved */
  396. unsigned check :1; /* Error occurred */
  397. #else
  398. #error "Bitfield endianness not defined! Check your byteorder.h"
  399. #endif
  400. } b;
  401. } idefloppy_status_reg_t;
  403. /*
  404.  * The ATAPI error register.
  405.  */
  406. typedef union {
  407. unsigned all :8;
  408. struct {
  409. #if defined(__LITTLE_ENDIAN_BITFIELD)
  410. unsigned ili :1; /* Illegal Length Indication */
  411. unsigned eom :1; /* End Of Media Detected */
  412. unsigned abrt :1; /* Aborted command - As defined by ATA */
  413. unsigned mcr :1; /* Media Change Requested - As defined by ATA */
  414. unsigned sense_key :4; /* Sense key of the last failed packet command */
  415. #elif defined(__BIG_ENDIAN_BITFIELD)
  416. unsigned sense_key :4; /* Sense key of the last failed packet command */
  417. unsigned mcr :1; /* Media Change Requested - As defined by ATA */
  418. unsigned abrt :1; /* Aborted command - As defined by ATA */
  419. unsigned eom :1; /* End Of Media Detected */
  420. unsigned ili :1; /* Illegal Length Indication */
  421. #else
  422. #error "Bitfield endianness not defined! Check your byteorder.h"
  423. #endif
  424. } b;
  425. } idefloppy_error_reg_t;
  427. /*
  428.  * ATAPI Feature Register
  429.  */
  430. typedef union {
  431. unsigned all :8;
  432. struct {
  433. #if defined(__LITTLE_ENDIAN_BITFIELD)
  434. unsigned dma :1; /* Using DMA or PIO */
  435. unsigned reserved321 :3; /* Reserved */
  436. unsigned reserved654 :3; /* Reserved (Tag Type) */
  437. unsigned reserved7 :1; /* Reserved */
  438. #elif defined(__BIG_ENDIAN_BITFIELD)
  439. unsigned reserved7 :1; /* Reserved */
  440. unsigned reserved654 :3; /* Reserved (Tag Type) */
  441. unsigned reserved321 :3; /* Reserved */
  442. unsigned dma :1; /* Using DMA or PIO */
  443. #else
  444. #error "Bitfield endianness not defined! Check your byteorder.h"
  445. #endif
  446. } b;
  447. } idefloppy_feature_reg_t;
  449. /*
  450.  * ATAPI Byte Count Register.
  451.  */
  452. typedef union {
  453. unsigned all :16;
  454. struct {
  455. #if defined(__LITTLE_ENDIAN_BITFIELD)
  456. unsigned low :8; /* LSB */
  457. unsigned high :8; /* MSB */
  458. #elif defined(__BIG_ENDIAN_BITFIELD)
  459. unsigned high :8; /* MSB */
  460. unsigned low :8; /* LSB */
  461. #else
  462. #error "Bitfield endianness not defined! Check your byteorder.h"
  463. #endif
  464. } b;
  465. } idefloppy_bcount_reg_t;
  467. /*
  468.  * ATAPI Interrupt Reason Register.
  469.  */
  470. typedef union {
  471. unsigned all :8;
  472. struct {
  473. #if defined(__LITTLE_ENDIAN_BITFIELD)
  474. unsigned cod :1; /* Information transferred is command (1) or data (0) */
  475. unsigned io :1; /* The device requests us to read (1) or write (0) */
  476. unsigned reserved :6; /* Reserved */
  477. #elif defined(__BIG_ENDIAN_BITFIELD)
  478. unsigned reserved :6; /* Reserved */
  479. unsigned io :1; /* The device requests us to read (1) or write (0) */
  480. unsigned cod :1; /* Information transferred is command (1) or data (0) */
  481. #else
  482. #error "Bitfield endianness not defined! Check your byteorder.h"
  483. #endif
  484. } b;
  485. } idefloppy_ireason_reg_t;
  487. /*
  488.  * ATAPI floppy Drive Select Register
  489.  */
  490. typedef union {
  491. unsigned all :8;
  492. struct {
  493. #if defined(__LITTLE_ENDIAN_BITFIELD)
  494. unsigned sam_lun :3; /* Logical unit number */
  495. unsigned reserved3 :1; /* Reserved */
  496. unsigned drv :1; /* The responding drive will be drive 0 (0) or drive 1 (1) */
  497. unsigned one5 :1; /* Should be set to 1 */
  498. unsigned reserved6 :1; /* Reserved */
  499. unsigned one7 :1; /* Should be set to 1 */
  500. #elif defined(__BIG_ENDIAN_BITFIELD)
  501. unsigned one7 :1; /* Should be set to 1 */
  502. unsigned reserved6 :1; /* Reserved */
  503. unsigned one5 :1; /* Should be set to 1 */
  504. unsigned drv :1; /* The responding drive will be drive 0 (0) or drive 1 (1) */
  505. unsigned reserved3 :1; /* Reserved */
  506. unsigned sam_lun :3; /* Logical unit number */
  507. #else
  508. #error "Bitfield endianness not defined! Check your byteorder.h"
  509. #endif
  510. } b;
  511. } idefloppy_drivesel_reg_t;
  513. /*
  514.  * ATAPI Device Control Register
  515.  */
  516. typedef union {
  517. unsigned all :8;
  518. struct {
  519. #if defined(__LITTLE_ENDIAN_BITFIELD)
  520. unsigned zero0 :1; /* Should be set to zero */
  521. unsigned nien :1; /* Device interrupt is disabled (1) or enabled (0) */
  522. unsigned srst :1; /* ATA software reset. ATAPI devices should use the new ATAPI srst. */
  523. unsigned one3 :1; /* Should be set to 1 */
  524. unsigned reserved4567 :4; /* Reserved */
  525. #elif defined(__BIG_ENDIAN_BITFIELD)
  526. unsigned reserved4567 :4; /* Reserved */
  527. unsigned one3 :1; /* Should be set to 1 */
  528. unsigned srst :1; /* ATA software reset. ATAPI devices should use the new ATAPI srst. */
  529. unsigned nien :1; /* Device interrupt is disabled (1) or enabled (0) */
  530. unsigned zero0 :1; /* Should be set to zero */
  531. #else
  532. #error "Bitfield endianness not defined! Check your byteorder.h"
  533. #endif
  534. } b;
  535. } idefloppy_control_reg_t;
  537. /*
  538.  * The following is used to format the general configuration word of
  539.  * the ATAPI IDENTIFY DEVICE command.
  540.  */
  541. struct idefloppy_id_gcw {
  542. #if defined(__LITTLE_ENDIAN_BITFIELD)
  543. unsigned packet_size :2; /* Packet Size */
  544. unsigned reserved234 :3; /* Reserved */
  545. unsigned drq_type :2; /* Command packet DRQ type */
  546. unsigned removable :1; /* Removable media */
  547. unsigned device_type :5; /* Device type */
  548. unsigned reserved13 :1; /* Reserved */
  549. unsigned protocol :2; /* Protocol type */
  550. #elif defined(__BIG_ENDIAN_BITFIELD)
  551. unsigned protocol :2; /* Protocol type */
  552. unsigned reserved13 :1; /* Reserved */
  553. unsigned device_type :5; /* Device type */
  554. unsigned removable :1; /* Removable media */
  555. unsigned drq_type :2; /* Command packet DRQ type */
  556. unsigned reserved234 :3; /* Reserved */
  557. unsigned packet_size :2; /* Packet Size */
  558. #else
  559. #error "Bitfield endianness not defined! Check your byteorder.h"
  560. #endif
  561. };
  563. /*
  564.  * INQUIRY packet command - Data Format
  565.  */
  566. typedef struct {
  567. #if defined(__LITTLE_ENDIAN_BITFIELD)
  568. unsigned device_type :5; /* Peripheral Device Type */
  569. unsigned reserved0_765 :3; /* Peripheral Qualifier - Reserved */
  570. unsigned reserved1_6t0 :7; /* Reserved */
  571. unsigned rmb :1; /* Removable Medium Bit */
  572. unsigned ansi_version :3; /* ANSI Version */
  573. unsigned ecma_version :3; /* ECMA Version */
  574. unsigned iso_version :2; /* ISO Version */
  575. unsigned response_format :4; /* Response Data Format */
  576. unsigned reserved3_45 :2; /* Reserved */
  577. unsigned reserved3_6 :1; /* TrmIOP - Reserved */
  578. unsigned reserved3_7 :1; /* AENC - Reserved */
  579. #elif defined(__BIG_ENDIAN_BITFIELD)
  580. unsigned reserved0_765 :3; /* Peripheral Qualifier - Reserved */
  581. unsigned device_type :5; /* Peripheral Device Type */
  582. unsigned rmb :1; /* Removable Medium Bit */
  583. unsigned reserved1_6t0 :7; /* Reserved */
  584. unsigned iso_version :2; /* ISO Version */
  585. unsigned ecma_version :3; /* ECMA Version */
  586. unsigned ansi_version :3; /* ANSI Version */
  587. unsigned reserved3_7 :1; /* AENC - Reserved */
  588. unsigned reserved3_6 :1; /* TrmIOP - Reserved */
  589. unsigned reserved3_45 :2; /* Reserved */
  590. unsigned response_format :4; /* Response Data Format */
  591. #else
  592. #error "Bitfield endianness not defined! Check your byteorder.h"
  593. #endif
  594. u8 additional_length; /* Additional Length (total_length-4) */
  595. u8 rsv5, rsv6, rsv7; /* Reserved */
  596. u8 vendor_id[8]; /* Vendor Identification */
  597. u8 product_id[16]; /* Product Identification */
  598. u8 revision_level[4]; /* Revision Level */
  599. u8 vendor_specific[20]; /* Vendor Specific - Optional */
  600. u8 reserved56t95[40]; /* Reserved - Optional */
  601. /* Additional information may be returned */
  602. } idefloppy_inquiry_result_t;
  604. /*
  605.  * REQUEST SENSE packet command result - Data Format.
  606.  */
  607. typedef struct {
  608. #if defined(__LITTLE_ENDIAN_BITFIELD)
  609. unsigned error_code :7; /* Current error (0x70) */
  610. unsigned valid :1; /* The information field conforms to SFF-8070i */
  611. u8 reserved1 :8; /* Reserved */
  612. unsigned sense_key :4; /* Sense Key */
  613. unsigned reserved2_4 :1; /* Reserved */
  614. unsigned ili :1; /* Incorrect Length Indicator */
  615. unsigned reserved2_67 :2;
  616. #elif defined(__BIG_ENDIAN_BITFIELD)
  617. unsigned valid :1; /* The information field conforms to SFF-8070i */
  618. unsigned error_code :7; /* Current error (0x70) */
  619. u8 reserved1 :8; /* Reserved */
  620. unsigned reserved2_67 :2;
  621. unsigned ili :1; /* Incorrect Length Indicator */
  622. unsigned reserved2_4 :1; /* Reserved */
  623. unsigned sense_key :4; /* Sense Key */
  624. #else
  625. #error "Bitfield endianness not defined! Check your byteorder.h"
  626. #endif
  627. u32 information __attribute__ ((packed));
  628. u8 asl; /* Additional sense length (n-7) */
  629. u32 command_specific; /* Additional command specific information */
  630. u8 asc; /* Additional Sense Code */
  631. u8 ascq; /* Additional Sense Code Qualifier */
  632. u8 replaceable_unit_code; /* Field Replaceable Unit Code */
  633. u8 sksv[3];
  634. u8 pad[2]; /* Padding to 20 bytes */
  635. } idefloppy_request_sense_result_t;
  637. /*
  638.  * Pages of the SELECT SENSE / MODE SENSE packet commands.
  639.  */
  640. #define IDEFLOPPY_CAPABILITIES_PAGE 0x1b
  641. #define IDEFLOPPY_FLEXIBLE_DISK_PAGE 0x05
  643. /*
  644.  * Mode Parameter Header for the MODE SENSE packet command
  645.  */
  646. typedef struct {
  647. u16 mode_data_length; /* Length of the following data transfer */
  648. u8 medium_type; /* Medium Type */
  649. #if defined(__LITTLE_ENDIAN_BITFIELD)
  650. unsigned reserved3 :7;
  651. unsigned wp :1; /* Write protect */
  652. #elif defined(__BIG_ENDIAN_BITFIELD)
  653. unsigned wp :1; /* Write protect */
  654. unsigned reserved3 :7;
  655. #else
  656. #error "Bitfield endianness not defined! Check your byteorder.h"
  657. #endif
  658. u8 reserved[4];
  659. } idefloppy_mode_parameter_header_t;
  661. #define IDEFLOPPY_MIN(a,b) ((a)<(b) ? (a):(b))
  662. #define IDEFLOPPY_MAX(a,b) ((a)>(b) ? (a):(b))
  664. /*
  665.  * Too bad. The drive wants to send us data which we are not ready to accept.
  666.  * Just throw it away.
  667.  */
  668. static void idefloppy_discard_data (ide_drive_t *drive, unsigned int bcount)
  669. {
  670. while (bcount--)
  671. IN_BYTE (IDE_DATA_REG);
  672. }
  674. #if IDEFLOPPY_DEBUG_BUGS
  675. static void idefloppy_write_zeros (ide_drive_t *drive, unsigned int bcount)
  676. {
  677. while (bcount--)
  678. OUT_BYTE (0, IDE_DATA_REG);
  679. }
  680. #endif /* IDEFLOPPY_DEBUG_BUGS */
  682. /*
  683.  * idefloppy_end_request is used to finish servicing a request.
  684.  *
  685.  * For read/write requests, we will call ide_end_request to pass to the
  686.  * next buffer.
  687.  */
  688. static void idefloppy_end_request (byte uptodate, ide_hwgroup_t *hwgroup)
  689. {
  690. ide_drive_t *drive = hwgroup->drive;
  691. idefloppy_floppy_t *floppy = drive->driver_data;
  692. struct request *rq = hwgroup->rq;
  693. int error;
  695. #if IDEFLOPPY_DEBUG_LOG
  696. printk (KERN_INFO "Reached idefloppy_end_requestn");
  697. #endif /* IDEFLOPPY_DEBUG_LOG */
  699. switch (uptodate) {
  700. case 0: error = IDEFLOPPY_ERROR_GENERAL; break;
  701. case 1: error = 0; break;
  702. default: error = uptodate;
  703. }
  704. if (error)
  705. floppy->failed_pc = NULL;
  706. /* Why does this happen? */
  707. if (!rq)
  708. return;
  709. if (!IDEFLOPPY_RQ_CMD (rq->cmd)) {
  710. ide_end_request (uptodate, hwgroup);
  711. return;
  712. }
  713. rq->errors = error;
  714. ide_end_drive_cmd (drive, 0, 0);
  715. }
  717. static void idefloppy_input_buffers (ide_drive_t *drive, idefloppy_pc_t *pc, unsigned int bcount)
  718. {
  719. struct request *rq = pc->rq;
  720. struct buffer_head *bh = rq->bh;
  721. int count;
  723. while (bcount) {
  724. if (pc->b_count == bh->b_size) {
  725. rq->sector += rq->current_nr_sectors;
  726. rq->nr_sectors -= rq->current_nr_sectors;
  727. idefloppy_end_request (1, HWGROUP(drive));
  728. if ((bh = rq->bh) != NULL)
  729. pc->b_count = 0;
  730. }
  731. if (bh == NULL) {
  732. printk (KERN_ERR "%s: bh == NULL in idefloppy_input_buffers, bcount == %dn", drive->name, bcount);
  733. idefloppy_discard_data (drive, bcount);
  734. return;
  735. }
  736. count = IDEFLOPPY_MIN (bh->b_size - pc->b_count, bcount);
  737. atapi_input_bytes (drive, bh->b_data + pc->b_count, count);
  738. bcount -= count; pc->b_count += count;
  739. }
  740. }
  742. static void idefloppy_output_buffers (ide_drive_t *drive, idefloppy_pc_t *pc, unsigned int bcount)
  743. {
  744. struct request *rq = pc->rq;
  745. struct buffer_head *bh = rq->bh;
  746. int count;
  748. while (bcount) {
  749. if (!pc->b_count) {
  750. rq->sector += rq->current_nr_sectors;
  751. rq->nr_sectors -= rq->current_nr_sectors;
  752. idefloppy_end_request (1, HWGROUP(drive));
  753. if ((bh = rq->bh) != NULL) {
  754. pc->b_data = bh->b_data;
  755. pc->b_count = bh->b_size;
  756. }
  757. }
  758. if (bh == NULL) {
  759. printk (KERN_ERR "%s: bh == NULL in idefloppy_output_buffers, bcount == %dn", drive->name, bcount);
  760. idefloppy_write_zeros (drive, bcount);
  761. return;
  762. }
  763. count = IDEFLOPPY_MIN (pc->b_count, bcount);
  764. atapi_output_bytes (drive, pc->b_data, count);
  765. bcount -= count; pc->b_data += count; pc->b_count -= count;
  766. }
  767. }
  769. #ifdef CONFIG_BLK_DEV_IDEDMA
  770. static void idefloppy_update_buffers (ide_drive_t *drive, idefloppy_pc_t *pc)
  771. {
  772. struct request *rq = pc->rq;
  773. struct buffer_head *bh = rq->bh;
  775. while ((bh = rq->bh) != NULL)
  776. idefloppy_end_request (1, HWGROUP(drive));
  777. }
  778. #endif /* CONFIG_BLK_DEV_IDEDMA */
  780. /*
  781.  * idefloppy_queue_pc_head generates a new packet command request in front
  782.  * of the request queue, before the current request, so that it will be
  783.  * processed immediately, on the next pass through the driver.
  784.  */
  785. static void idefloppy_queue_pc_head (ide_drive_t *drive,idefloppy_pc_t *pc,struct request *rq)
  786. {
  787. ide_init_drive_cmd (rq);
  788. rq->buffer = (char *) pc;
  789. rq->cmd = IDEFLOPPY_PC_RQ;
  790. (void) ide_do_drive_cmd (drive, rq, ide_preempt);
  791. }
  793. static idefloppy_pc_t *idefloppy_next_pc_storage (ide_drive_t *drive)
  794. {
  795. idefloppy_floppy_t *floppy = drive->driver_data;
  797. if (floppy->pc_stack_index==IDEFLOPPY_PC_STACK)
  798. floppy->pc_stack_index=0;
  799. return (&floppy->pc_stack[floppy->pc_stack_index++]);
  800. }
  802. static struct request *idefloppy_next_rq_storage (ide_drive_t *drive)
  803. {
  804. idefloppy_floppy_t *floppy = drive->driver_data;
  806. if (floppy->rq_stack_index==IDEFLOPPY_PC_STACK)
  807. floppy->rq_stack_index=0;
  808. return (&floppy->rq_stack[floppy->rq_stack_index++]);
  809. }
  811. /*
  812.  * idefloppy_analyze_error is called on each failed packet command retry
  813.  * to analyze the request sense.
  814.  */
  815. static void idefloppy_analyze_error (ide_drive_t *drive,idefloppy_request_sense_result_t *result)
  816. {
  817. idefloppy_floppy_t *floppy = drive->driver_data;
  819. floppy->sense_key = result->sense_key; floppy->asc = result->asc; floppy->ascq = result->ascq;
  820. floppy->progress_indication= result->sksv[0] & 0x80 ?
  821. (unsigned short)get_unaligned((u16 *)(result->sksv+1)):0x10000;
  822. #if IDEFLOPPY_DEBUG_LOG
  823. if (floppy->failed_pc)
  824. printk (KERN_INFO "ide-floppy: pc = %x, sense key = %x, asc = %x, ascq = %xn",floppy->failed_pc->c[0],result->sense_key,result->asc,result->ascq);
  825. else
  826. printk (KERN_INFO "ide-floppy: sense key = %x, asc = %x, ascq = %xn",result->sense_key,result->asc,result->ascq);
  827. #endif /* IDEFLOPPY_DEBUG_LOG */
  828. }
  830. static void idefloppy_request_sense_callback (ide_drive_t *drive)
  831. {
  832. idefloppy_floppy_t *floppy = drive->driver_data;
  834. #if IDEFLOPPY_DEBUG_LOG
  835. printk (KERN_INFO "ide-floppy: Reached idefloppy_request_sense_callbackn");
  836. #endif /* IDEFLOPPY_DEBUG_LOG */
  837. if (!floppy->pc->error) {
  838. idefloppy_analyze_error (drive,(idefloppy_request_sense_result_t *) floppy->pc->buffer);
  839. idefloppy_end_request (1,HWGROUP (drive));
  840. } else {
  841. printk (KERN_ERR "Error in REQUEST SENSE itself - Aborting request!n");
  842. idefloppy_end_request (0,HWGROUP (drive));
  843. }
  844. }
  846. /*
  847.  * General packet command callback function.
  848.  */
  849. static void idefloppy_pc_callback (ide_drive_t *drive)
  850. {
  851. idefloppy_floppy_t *floppy = drive->driver_data;
  853. #if IDEFLOPPY_DEBUG_LOG
  854. printk (KERN_INFO "ide-floppy: Reached idefloppy_pc_callbackn");
  855. #endif /* IDEFLOPPY_DEBUG_LOG */
  857. idefloppy_end_request (floppy->pc->error ? 0:1, HWGROUP(drive));
  858. }
  860. /*
  861.  * idefloppy_init_pc initializes a packet command.
  862.  */
  863. static void idefloppy_init_pc (idefloppy_pc_t *pc)
  864. {
  865. memset (pc->c, 0, 12);
  866. pc->retries = 0;
  867. pc->flags = 0;
  868. pc->request_transfer = 0;
  869. pc->buffer = pc->pc_buffer;
  870. pc->buffer_size = IDEFLOPPY_PC_BUFFER_SIZE;
  871. pc->b_data = NULL;
  872. pc->callback = &idefloppy_pc_callback;
  873. }
  875. static void idefloppy_create_request_sense_cmd (idefloppy_pc_t *pc)
  876. {
  877. idefloppy_init_pc (pc);
  878. pc->c[0] = IDEFLOPPY_REQUEST_SENSE_CMD;
  879. pc->c[4] = 255;
  880. pc->request_transfer = 18;
  881. pc->callback = &idefloppy_request_sense_callback;
  882. }
  884. /*
  885.  * idefloppy_retry_pc is called when an error was detected during the
  886.  * last packet command. We queue a request sense packet command in
  887.  * the head of the request list.
  888.  */
  889. static void idefloppy_retry_pc (ide_drive_t *drive)
  890. {
  891. idefloppy_pc_t *pc;
  892. struct request *rq;
  893. idefloppy_error_reg_t error;
  895. error.all = IN_BYTE (IDE_ERROR_REG);
  896. pc = idefloppy_next_pc_storage (drive);
  897. rq = idefloppy_next_rq_storage (drive);
  898. idefloppy_create_request_sense_cmd (pc);
  899. idefloppy_queue_pc_head (drive, pc, rq);
  900. }
  902. /*
  903.  * idefloppy_pc_intr is the usual interrupt handler which will be called
  904.  * during a packet command.
  905.  */
  906. static ide_startstop_t idefloppy_pc_intr (ide_drive_t *drive)
  907. {
  908. idefloppy_floppy_t *floppy = drive->driver_data;
  909. idefloppy_status_reg_t status;
  910. idefloppy_bcount_reg_t bcount;
  911. idefloppy_ireason_reg_t ireason;
  912. idefloppy_pc_t *pc=floppy->pc;
  913. struct request *rq = pc->rq;
  914. unsigned int temp;
  916. #if IDEFLOPPY_DEBUG_LOG
  917. printk (KERN_INFO "ide-floppy: Reached idefloppy_pc_intr interrupt handlern");
  918. #endif /* IDEFLOPPY_DEBUG_LOG */
  920. #ifdef CONFIG_BLK_DEV_IDEDMA
  921. if (test_bit (PC_DMA_IN_PROGRESS, &pc->flags)) {
  922. if (HWIF(drive)->dmaproc(ide_dma_end, drive)) {
  923. set_bit (PC_DMA_ERROR, &pc->flags);
  924. } else {
  925. pc->actually_transferred=pc->request_transfer;
  926. idefloppy_update_buffers (drive, pc);
  927. }
  928. #if IDEFLOPPY_DEBUG_LOG
  929. printk (KERN_INFO "ide-floppy: DMA finishedn");
  930. #endif /* IDEFLOPPY_DEBUG_LOG */
  931. }
  932. #endif /* CONFIG_BLK_DEV_IDEDMA */
  934. status.all = GET_STAT(); /* Clear the interrupt */
  936. if (!status.b.drq) { /* No more interrupts */
  937. #if IDEFLOPPY_DEBUG_LOG
  938. printk (KERN_INFO "Packet command completed, %d bytes transferredn", pc->actually_transferred);
  939. #endif /* IDEFLOPPY_DEBUG_LOG */
  940. clear_bit (PC_DMA_IN_PROGRESS, &pc->flags);
  942. ide__sti(); /* local CPU only */
  944. if (status.b.check || test_bit (PC_DMA_ERROR, &pc->flags)) { /* Error detected */
  945. #if IDEFLOPPY_DEBUG_LOG
  946. printk (KERN_INFO "ide-floppy: %s: I/O errorn",drive->name);
  947. #endif /* IDEFLOPPY_DEBUG_LOG */
  948. rq->errors++;
  949. if (pc->c[0] == IDEFLOPPY_REQUEST_SENSE_CMD) {
  950. printk (KERN_ERR "ide-floppy: I/O error in request sense commandn");
  951. return ide_do_reset (drive);
  952. }
  953. idefloppy_retry_pc (drive); /* Retry operation */
  954. return ide_stopped; /* queued, but not started */
  955. }
  956. pc->error = 0;
  957. if (floppy->failed_pc == pc)
  958. floppy->failed_pc=NULL;
  959. pc->callback(drive); /* Command finished - Call the callback function */
  960. return ide_stopped;
  961. }
  962. #ifdef CONFIG_BLK_DEV_IDEDMA
  963. if (test_and_clear_bit (PC_DMA_IN_PROGRESS, &pc->flags)) {
  964. printk (KERN_ERR "ide-floppy: The floppy wants to issue more interrupts in DMA moden");
  965. (void) HWIF(drive)->dmaproc(ide_dma_off, drive);
  966. return ide_do_reset (drive);
  967. }
  968. #endif /* CONFIG_BLK_DEV_IDEDMA */
  969. bcount.b.high=IN_BYTE (IDE_BCOUNTH_REG); /* Get the number of bytes to transfer */
  970. bcount.b.low=IN_BYTE (IDE_BCOUNTL_REG); /* on this interrupt */
  971. ireason.all=IN_BYTE (IDE_IREASON_REG);
  973. if (ireason.b.cod) {
  974. printk (KERN_ERR "ide-floppy: CoD != 0 in idefloppy_pc_intrn");
  975. return ide_do_reset (drive);
  976. }
  977. if (ireason.b.io == test_bit (PC_WRITING, &pc->flags)) { /* Hopefully, we will never get here */
  978. printk (KERN_ERR "ide-floppy: We wanted to %s, ", ireason.b.io ? "Write":"Read");
  979. printk (KERN_ERR "but the floppy wants us to %s !n",ireason.b.io ? "Read":"Write");
  980. return ide_do_reset (drive);
  981. }
  982. if (!test_bit (PC_WRITING, &pc->flags)) { /* Reading - Check that we have enough space */
  983. temp = pc->actually_transferred + bcount.all;
  984. if ( temp > pc->request_transfer) {
  985. if (temp > pc->buffer_size) {
  986. printk (KERN_ERR "ide-floppy: The floppy wants to send us more data than expected - discarding datan");
  987. idefloppy_discard_data (drive,bcount.all);
  988. ide_set_handler (drive,&idefloppy_pc_intr,IDEFLOPPY_WAIT_CMD, NULL);
  989. return ide_started;
  990. }
  991. #if IDEFLOPPY_DEBUG_LOG
  992. printk (KERN_NOTICE "ide-floppy: The floppy wants to send us more data than expected - allowing transfern");
  993. #endif /* IDEFLOPPY_DEBUG_LOG */
  994. }
  995. }
  996. if (test_bit (PC_WRITING, &pc->flags)) {
  997. if (pc->buffer != NULL)
  998. atapi_output_bytes (drive,pc->current_position,bcount.all); /* Write the current buffer */
  999. else
  1000. idefloppy_output_buffers (drive, pc, bcount.all);
  1001. } else {
  1002. if (pc->buffer != NULL)
  1003. atapi_input_bytes (drive,pc->current_position,bcount.all); /* Read the current buffer */
  1004. else
  1005. idefloppy_input_buffers (drive, pc, bcount.all);
  1006. }
  1007. pc->actually_transferred+=bcount.all; /* Update the current position */
  1008. pc->current_position+=bcount.all;
  1010. ide_set_handler (drive,&idefloppy_pc_intr,IDEFLOPPY_WAIT_CMD, NULL); /* And set the interrupt handler again */
  1011. return ide_started;
  1012. }
  1014. /*
  1015.  * This is the original routine that did the packet transfer.
  1016.  * It fails at high speeds on the Iomega ZIP drive, so there's a slower version
  1017.  * for that drive below. The algorithm is chosen based on drive type
  1018.  */
  1019. static ide_startstop_t idefloppy_transfer_pc (ide_drive_t *drive)
  1020. {
  1021. ide_startstop_t startstop;
  1022. idefloppy_floppy_t *floppy = drive->driver_data;
  1023. idefloppy_ireason_reg_t ireason;
  1025. if (ide_wait_stat (&startstop,drive,DRQ_STAT,BUSY_STAT,WAIT_READY)) {
  1026. printk (KERN_ERR "ide-floppy: Strange, packet command initiated yet DRQ isn't assertedn");
  1027. return startstop;
  1028. }
  1029. ireason.all=IN_BYTE (IDE_IREASON_REG);
  1030. if (!ireason.b.cod || ireason.b.io) {
  1031. printk (KERN_ERR "ide-floppy: (IO,CoD) != (0,1) while issuing a packet commandn");
  1032. return ide_do_reset (drive);
  1033. }
  1034. ide_set_handler (drive, &idefloppy_pc_intr, IDEFLOPPY_WAIT_CMD, NULL); /* Set the interrupt routine */
  1035. atapi_output_bytes (drive, floppy->pc->c, 12); /* Send the actual packet */
  1036. return ide_started;
  1037. }
  1040. /*
  1041.  * What we have here is a classic case of a top half / bottom half
  1042.  * interrupt service routine. In interrupt mode, the device sends
  1043.  * an interrupt to signal it's ready to receive a packet. However,
  1044.  * we need to delay about 2-3 ticks before issuing the packet or we
  1045.  * gets in trouble.
  1046.  *
  1047.  * So, follow carefully. transfer_pc1 is called as an interrupt (or
  1048.  * directly). In either case, when the device says it's ready for a 
  1049.  * packet, we schedule the packet transfer to occur about 2-3 ticks
  1050.  * later in transfer_pc2.
  1051.  */
  1052. static int idefloppy_transfer_pc2 (ide_drive_t *drive)
  1053. {
  1054. idefloppy_floppy_t *floppy = drive->driver_data;
  1056. atapi_output_bytes (drive, floppy->pc->c, 12); /* Send the actual packet */
  1057. return IDEFLOPPY_WAIT_CMD; /* Timeout for the packet command */
  1058. }
  1060. static ide_startstop_t idefloppy_transfer_pc1 (ide_drive_t *drive)
  1061. {
  1062. idefloppy_floppy_t *floppy = drive->driver_data;
  1063. ide_startstop_t startstop;
  1064. idefloppy_ireason_reg_t ireason;
  1066. if (ide_wait_stat (&startstop,drive,DRQ_STAT,BUSY_STAT,WAIT_READY)) {
  1067. printk (KERN_ERR "ide-floppy: Strange, packet command initiated yet DRQ isn't assertedn");
  1068. return startstop;
  1069. }
  1070. ireason.all=IN_BYTE (IDE_IREASON_REG);
  1071. if (!ireason.b.cod || ireason.b.io) {
  1072. printk (KERN_ERR "ide-floppy: (IO,CoD) != (0,1) while issuing a packet commandn");
  1073. return ide_do_reset (drive);
  1074. }
  1075. /* 
  1076.  * The following delay solves a problem with ATAPI Zip 100 drives where the
  1077.  * Busy flag was apparently being deasserted before the unit was ready to
  1078.  * receive data. This was happening on a 1200 MHz Athlon system. 10/26/01
  1079.  * 25msec is too short, 40 and 50msec work well. idefloppy_pc_intr will 
  1080.  * not be actually used until after the packet is moved in about 50 msec.
  1081.  */
  1082. ide_set_handler (drive, 
  1083.   &idefloppy_pc_intr,  /* service routine for packet command */
  1084.   floppy->ticks, /* wait this long before "failing" */
  1085.   &idefloppy_transfer_pc2); /* fail == transfer_pc2 */
  1086. return ide_started;
  1087. }
  1089. /*
  1090.  * Issue a packet command
  1091.  */
  1092. static ide_startstop_t idefloppy_issue_pc (ide_drive_t *drive, idefloppy_pc_t *pc)
  1093. {
  1094. idefloppy_floppy_t *floppy = drive->driver_data;
  1095. idefloppy_bcount_reg_t bcount;
  1096. int dma_ok = 0;
  1097. ide_handler_t *pkt_xfer_routine;
  1099. #if IDEFLOPPY_DEBUG_BUGS
  1100. if (floppy->pc->c[0] == IDEFLOPPY_REQUEST_SENSE_CMD && pc->c[0] == IDEFLOPPY_REQUEST_SENSE_CMD) {
  1101. printk (KERN_ERR "ide-floppy: possible ide-floppy.c bug - Two request sense in serial were issuedn");
  1102. }
  1103. #endif /* IDEFLOPPY_DEBUG_BUGS */
  1105. if (floppy->failed_pc == NULL && pc->c[0] != IDEFLOPPY_REQUEST_SENSE_CMD)
  1106. floppy->failed_pc=pc;
  1107. floppy->pc=pc; /* Set the current packet command */
  1109. if (pc->retries > IDEFLOPPY_MAX_PC_RETRIES || test_bit (PC_ABORT, &pc->flags)) {
  1110. /*
  1111.  * We will "abort" retrying a packet command in case
  1112.  * a legitimate error code was received.
  1113.  */
  1114. if (!test_bit (PC_ABORT, &pc->flags)) {
  1115. if (!test_bit (PC_SUPPRESS_ERROR, &pc->flags)) {
  1116. ;
  1117.       printk( KERN_ERR "ide-floppy: %s: I/O error, pc = %2x, key = %2x, asc = %2x, ascq = %2xn",
  1118. drive->name, pc->c[0], floppy->sense_key, floppy->asc, floppy->ascq);
  1119. }
  1120. pc->error = IDEFLOPPY_ERROR_GENERAL; /* Giving up */
  1121. }
  1122. floppy->failed_pc=NULL;
  1123. pc->callback(drive);
  1124. return ide_stopped;
  1125. }
  1126. #if IDEFLOPPY_DEBUG_LOG
  1127. printk (KERN_INFO "Retry number - %dn",pc->retries);
  1128. #endif /* IDEFLOPPY_DEBUG_LOG */
  1130. pc->retries++;
  1131. pc->actually_transferred=0; /* We haven't transferred any data yet */
  1132. pc->current_position=pc->buffer;
  1133. bcount.all = IDE_MIN(pc->request_transfer, 63 * 1024);
  1135. #ifdef CONFIG_BLK_DEV_IDEDMA
  1136. if (test_and_clear_bit (PC_DMA_ERROR, &pc->flags)) {
  1137. (void) HWIF(drive)->dmaproc(ide_dma_off, drive);
  1138. }
  1139. if (test_bit (PC_DMA_RECOMMENDED, &pc->flags) && drive->using_dma)
  1140. dma_ok=!HWIF(drive)->dmaproc(test_bit (PC_WRITING, &pc->flags) ? ide_dma_write : ide_dma_read, drive);
  1141. #endif /* CONFIG_BLK_DEV_IDEDMA */
  1143. if (IDE_CONTROL_REG)
  1144. OUT_BYTE (drive->ctl,IDE_CONTROL_REG);
  1145. OUT_BYTE (dma_ok ? 1:0,IDE_FEATURE_REG); /* Use PIO/DMA */
  1146. OUT_BYTE (bcount.b.high,IDE_BCOUNTH_REG);
  1147. OUT_BYTE (bcount.b.low,IDE_BCOUNTL_REG);
  1148. OUT_BYTE (drive->select.all,IDE_SELECT_REG);
  1150. #ifdef CONFIG_BLK_DEV_IDEDMA
  1151. if (dma_ok) { /* Begin DMA, if necessary */
  1152. set_bit (PC_DMA_IN_PROGRESS, &pc->flags);
  1153. (void) (HWIF(drive)->dmaproc(ide_dma_begin, drive));
  1154. }
  1155. #endif /* CONFIG_BLK_DEV_IDEDMA */
  1157. /* Can we transfer the packet when we get the interrupt or wait? */
  1158. if (test_bit (IDEFLOPPY_ZIP_DRIVE, &floppy->flags)) {
  1159. pkt_xfer_routine = &idefloppy_transfer_pc1; /* wait */
  1160. } else {
  1161. pkt_xfer_routine = &idefloppy_transfer_pc; /* immediate */
  1162. }
  1164. if (test_bit (IDEFLOPPY_DRQ_INTERRUPT, &floppy->flags)) {
  1165. ide_set_handler (drive, pkt_xfer_routine, IDEFLOPPY_WAIT_CMD, NULL);
  1166. OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG); /* Issue the packet command */
  1167. return ide_started;
  1168. } else {
  1169. OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG);
  1170. return (*pkt_xfer_routine) (drive);
  1171. }
  1172. }
  1174. static void idefloppy_rw_callback (ide_drive_t *drive)
  1175. {
  1176. #if IDEFLOPPY_DEBUG_LOG
  1177. printk (KERN_INFO "ide-floppy: Reached idefloppy_rw_callbackn");
  1178. #endif /* IDEFLOPPY_DEBUG_LOG */
  1180. idefloppy_end_request(1, HWGROUP(drive));
  1181. return;
  1182. }
  1184. static void idefloppy_create_prevent_cmd (idefloppy_pc_t *pc, int prevent)
  1185. {
  1186. #if IDEFLOPPY_DEBUG_LOG
  1187. printk (KERN_INFO "ide-floppy: creating prevent removal command, prevent = %dn", prevent);
  1188. #endif /* IDEFLOPPY_DEBUG_LOG */
  1190. idefloppy_init_pc (pc);
  1191. pc->c[0] = IDEFLOPPY_PREVENT_REMOVAL_CMD;
  1192. pc->c[4] = prevent;
  1193. }
  1195. static void idefloppy_create_read_capacity_cmd (idefloppy_pc_t *pc)
  1196. {
  1197. idefloppy_init_pc (pc);
  1198. pc->c[0] = IDEFLOPPY_READ_CAPACITY_CMD;
  1199. pc->c[7] = 255;
  1200. pc->c[8] = 255;
  1201. pc->request_transfer = 255;
  1202. }
  1204. static void idefloppy_create_format_unit_cmd (idefloppy_pc_t *pc, int b, int l,
  1205.       int flags)
  1206. {
  1207. idefloppy_init_pc (pc);
  1208. pc->c[0] = IDEFLOPPY_FORMAT_UNIT_CMD;
  1209. pc->c[1] = 0x17;
  1211. memset(pc->buffer, 0, 12);
  1212. pc->buffer[1] = 0xA2;
  1213. /* Default format list header, byte 1: FOV/DCRT/IMM bits set */
  1215. if (flags & 1) /* Verify bit on... */
  1216. pc->buffer[1] ^= 0x20; /* ... turn off DCRT bit */
  1217. pc->buffer[3] = 8;
  1219. put_unaligned(htonl(b), (unsigned int *)(&pc->buffer[4]));
  1220. put_unaligned(htonl(l), (unsigned int *)(&pc->buffer[8]));
  1221. pc->buffer_size=12;
  1222. set_bit(PC_WRITING, &pc->flags);
  1223. }
  1225. /*
  1226.  * A mode sense command is used to "sense" floppy parameters.
  1227.  */
  1228. static void idefloppy_create_mode_sense_cmd (idefloppy_pc_t *pc, byte page_code, byte type)
  1229. {
  1230. unsigned short length = sizeof (idefloppy_mode_parameter_header_t);
  1232. idefloppy_init_pc (pc);
  1233. pc->c[0] = IDEFLOPPY_MODE_SENSE_CMD;
  1234. pc->c[1] = 0;
  1235. pc->c[2] = page_code + (type << 6);
  1237. switch (page_code) {
  1238. case IDEFLOPPY_CAPABILITIES_PAGE:
  1239. length += 12;
  1240. break;
  1241. case IDEFLOPPY_FLEXIBLE_DISK_PAGE:
  1242. length += 32;
  1243. break;
  1244. default:
  1245. printk (KERN_ERR "ide-floppy: unsupported page code in create_mode_sense_cmdn");
  1246. }
  1247. put_unaligned (htons (length), (unsigned short *) &pc->c[7]);
  1248. pc->request_transfer = length;
  1249. }
  1251. static void idefloppy_create_start_stop_cmd (idefloppy_pc_t *pc, int start)
  1252. {
  1253. idefloppy_init_pc (pc);
  1254. pc->c[0] = IDEFLOPPY_START_STOP_CMD;
  1255. pc->c[4] = start;
  1256. }
  1258. static void idefloppy_create_test_unit_ready_cmd(idefloppy_pc_t *pc)
  1259. {
  1260. idefloppy_init_pc(pc);
  1261. pc->c[0] = IDEFLOPPY_TEST_UNIT_READY_CMD;
  1262. }
  1264. static void idefloppy_create_rw_cmd (idefloppy_floppy_t *floppy, idefloppy_pc_t *pc, struct request *rq, unsigned long sector)
  1265. {
  1266. int block = sector / floppy->bs_factor;
  1267. int blocks = rq->nr_sectors / floppy->bs_factor;
  1269. #if IDEFLOPPY_DEBUG_LOG
  1270. printk ("create_rw1%d_cmd: block == %d, blocks == %dn",
  1271. 2 * test_bit (IDEFLOPPY_USE_READ12, &floppy->flags), block, blocks);
  1272. #endif /* IDEFLOPPY_DEBUG_LOG */
  1274. idefloppy_init_pc (pc);
  1275. if (test_bit (IDEFLOPPY_USE_READ12, &floppy->flags)) {
  1276. pc->c[0] = rq->cmd == READ ? IDEFLOPPY_READ12_CMD : IDEFLOPPY_WRITE12_CMD;
  1277. put_unaligned (htonl (blocks), (unsigned int *) &pc->c[6]);
  1278. } else {
  1279. pc->c[0] = rq->cmd == READ ? IDEFLOPPY_READ10_CMD : IDEFLOPPY_WRITE10_CMD;
  1280. put_unaligned (htons (blocks), (unsigned short *) &pc->c[7]);
  1281. }
  1282. put_unaligned (htonl (block), (unsigned int *) &pc->c[2]);
  1283. pc->callback = &idefloppy_rw_callback;
  1284. pc->rq = rq;
  1285. pc->b_data = rq->buffer;
  1286. pc->b_count = rq->cmd == READ ? 0 : rq->bh->b_size;
  1287. if (rq->cmd == WRITE)
  1288. set_bit (PC_WRITING, &pc->flags);
  1289. pc->buffer = NULL;
  1290. pc->request_transfer = pc->buffer_size = blocks * floppy->block_size;
  1291. set_bit (PC_DMA_RECOMMENDED, &pc->flags);
  1292. }
  1294. /*
  1295.  * idefloppy_do_request is our request handling function.
  1296.  */
  1297. static ide_startstop_t idefloppy_do_request (ide_drive_t *drive, struct request *rq, unsigned long block)
  1298. {
  1299. idefloppy_floppy_t *floppy = drive->driver_data;
  1300. idefloppy_pc_t *pc;
  1302. #if IDEFLOPPY_DEBUG_LOG
  1303. printk (KERN_INFO "rq_status: %d, rq_dev: %u, cmd: %d, errors: %dn",rq->rq_status,(unsigned int) rq->rq_dev,rq->cmd,rq->errors);
  1304. printk (KERN_INFO "sector: %ld, nr_sectors: %ld, current_nr_sectors: %ldn",rq->sector,rq->nr_sectors,rq->current_nr_sectors);
  1305. #endif /* IDEFLOPPY_DEBUG_LOG */
  1307. if (rq->errors >= ERROR_MAX) {
  1308. if (floppy->failed_pc != NULL)
  1309. printk (KERN_ERR "ide-floppy: %s: I/O error, pc = %2x, key = %2x, asc = %2x, ascq = %2xn",
  1310. drive->name, floppy->failed_pc->c[0], floppy->sense_key, floppy->asc, floppy->ascq);
  1311. else
  1312. printk (KERN_ERR "ide-floppy: %s: I/O errorn", drive->name);
  1313. idefloppy_end_request (0, HWGROUP(drive));
  1314. return ide_stopped;
  1315. }
  1316. switch (rq->cmd) {
  1317. case READ:
  1318. case WRITE:
  1319. if (rq->sector % floppy->bs_factor || rq->nr_sectors % floppy->bs_factor) {
  1320. printk ("%s: unsupported r/w request sizen", drive->name);
  1321. idefloppy_end_request (0, HWGROUP(drive));
  1322. return ide_stopped;
  1323. }
  1324. pc = idefloppy_next_pc_storage (drive);
  1325. idefloppy_create_rw_cmd (floppy, pc, rq, block);
  1326. break;
  1327. case IDEFLOPPY_PC_RQ:
  1328. pc = (idefloppy_pc_t *) rq->buffer;
  1329. break;
  1330. default:
  1331. printk (KERN_ERR "ide-floppy: unsupported command %x in request queuen", rq->cmd);
  1332. idefloppy_end_request (0,HWGROUP (drive));
  1333. return ide_stopped;
  1334. }
  1335. pc->rq = rq;
  1336. return idefloppy_issue_pc (drive, pc);
  1337. }
  1339. /*
  1340.  * idefloppy_queue_pc_tail adds a special packet command request to the
  1341.  * tail of the request queue, and waits for it to be serviced.
  1342.  */
  1343. static int idefloppy_queue_pc_tail (ide_drive_t *drive,idefloppy_pc_t *pc)
  1344. {
  1345. struct request rq;
  1347. ide_init_drive_cmd (&rq);
  1348. rq.buffer = (char *) pc;
  1349. rq.cmd = IDEFLOPPY_PC_RQ;
  1350. return ide_do_drive_cmd (drive, &rq, ide_wait);
  1351. }
  1353. /*
  1354.  * Look at the flexible disk page parameters. We will ignore the CHS
  1355.  * capacity parameters and use the LBA parameters instead.
  1356.  */
  1357. static int idefloppy_get_flexible_disk_page (ide_drive_t *drive)
  1358. {
  1359. idefloppy_floppy_t *floppy = drive->driver_data;
  1360. idefloppy_pc_t pc;
  1361. idefloppy_mode_parameter_header_t *header;
  1362. idefloppy_flexible_disk_page_t *page;
  1363. int capacity, lba_capacity;
  1365. idefloppy_create_mode_sense_cmd (&pc, IDEFLOPPY_FLEXIBLE_DISK_PAGE, MODE_SENSE_CURRENT);
  1366. if (idefloppy_queue_pc_tail (drive,&pc)) {
  1367. printk (KERN_ERR "ide-floppy: Can't get flexible disk page parametersn");
  1368. return 1;
  1369. }
  1370. header = (idefloppy_mode_parameter_header_t *) pc.buffer;
  1371. floppy->wp = header->wp;
  1372. page = (idefloppy_flexible_disk_page_t *) (header + 1);
  1374. page->transfer_rate = ntohs (page->transfer_rate);
  1375. page->sector_size = ntohs (page->sector_size);
  1376. page->cyls = ntohs (page->cyls);
  1377. page->rpm = ntohs (page->rpm);
  1378. capacity = page->cyls * page->heads * page->sectors * page->sector_size;
  1379. if (memcmp (page, &floppy->flexible_disk_page, sizeof (idefloppy_flexible_disk_page_t)))
  1380. printk (KERN_INFO "%s: %dkB, %d/%d/%d CHS, %d kBps, %d sector size, %d rpmn",
  1381. drive->name, capacity / 1024, page->cyls, page->heads, page->sectors,
  1382. page->transfer_rate / 8, page->sector_size, page->rpm);
  1384. floppy->flexible_disk_page = *page;
  1385. drive->bios_cyl = page->cyls;
  1386. drive->bios_head = page->heads;
  1387. drive->bios_sect = page->sectors;
  1388. lba_capacity = floppy->blocks * floppy->block_size;
  1389. if (capacity < lba_capacity) {
  1390. printk (KERN_NOTICE "%s: The disk reports a capacity of %d bytes, "
  1391. "but the drive only handles %dn",
  1392. drive->name, lba_capacity, capacity);
  1393. floppy->blocks = floppy->block_size ? capacity / floppy->block_size : 0;
  1394. }
  1395. return 0;
  1396. }
  1398. static int idefloppy_get_capability_page(ide_drive_t *drive)
  1399. {
  1400. idefloppy_floppy_t *floppy = drive->driver_data;
  1401. idefloppy_pc_t pc;
  1402. idefloppy_mode_parameter_header_t *header;
  1403. idefloppy_capabilities_page_t *page;
  1405. floppy->srfp=0;
  1406. idefloppy_create_mode_sense_cmd (&pc, IDEFLOPPY_CAPABILITIES_PAGE,
  1407.  MODE_SENSE_CURRENT);
  1409. set_bit(PC_SUPPRESS_ERROR, &pc.flags);
  1410. if (idefloppy_queue_pc_tail (drive,&pc)) {
  1411. return 1;
  1412. }
  1414. header = (idefloppy_mode_parameter_header_t *) pc.buffer;
  1415. page= (idefloppy_capabilities_page_t *)(header+1);
  1416. floppy->srfp=page->srfp;
  1417. return (0);
  1418. }
  1420. /*
  1421.  * Determine if a media is present in the floppy drive, and if so,
  1422.  * its LBA capacity.
  1423.  */
  1424. static int idefloppy_get_capacity (ide_drive_t *drive)
  1425. {
  1426. idefloppy_floppy_t *floppy = drive->driver_data;
  1427. idefloppy_pc_t pc;
  1428. idefloppy_capacity_header_t *header;
  1429. idefloppy_capacity_descriptor_t *descriptor;
  1430. int i, descriptors, rc = 1, blocks, length;
  1432. drive->bios_cyl = 0;
  1433. drive->bios_head = drive->bios_sect = 0;
  1434. floppy->blocks = floppy->bs_factor = 0;
  1435. drive->part[0].nr_sects = 0;
  1437. idefloppy_create_read_capacity_cmd (&pc);
  1438. if (idefloppy_queue_pc_tail (drive, &pc)) {
  1439. printk (KERN_ERR "ide-floppy: Can't get floppy parametersn");
  1440. return 1;
  1441. }
  1442. header = (idefloppy_capacity_header_t *) pc.buffer;
  1443. descriptors = header->length / sizeof (idefloppy_capacity_descriptor_t);
  1444. descriptor = (idefloppy_capacity_descriptor_t *) (header + 1);
  1446. for (i = 0; i < descriptors; i++, descriptor++) {
  1447.                 blocks = descriptor->blocks = ntohl (descriptor->blocks);
  1448.                 length = descriptor->length = ntohs (descriptor->length);
  1450. if (!i) 
  1451. {
  1452.            switch (descriptor->dc) {
  1453.                 case CAPACITY_UNFORMATTED: /* Clik! drive returns this instead of CAPACITY_CURRENT */
  1454.                         if (!test_bit(IDEFLOPPY_CLIK_DRIVE, &floppy->flags))
  1455.                                 break; /* If it is not a clik drive, break out (maintains previous driver behaviour) */
  1456.                 case CAPACITY_CURRENT: /* Normal Zip/LS-120 disks */
  1457.                         if (memcmp (descriptor, &floppy->capacity, sizeof (idefloppy_capacity_descriptor_t)))
  1458.                                 printk (KERN_INFO "%s: %dkB, %d blocks, %d sector sizen", drive->name, blocks * length / 1024, blocks, length);
  1459.                         floppy->capacity = *descriptor;
  1460.                         if (!length || length % 512)
  1461.                                 printk (KERN_NOTICE "%s: %d bytes block size not supportedn", drive->name, length);
  1462.                         else {
  1463.                                 floppy->blocks = blocks;
  1464.                                 floppy->block_size = length;
  1465.                                 if ((floppy->bs_factor = length / 512) != 1)
  1466.                                         printk (KERN_NOTICE "%s: warning: non 512 bytes block size not fully supportedn", drive->name);
  1467.                                 rc = 0;
  1468.                         }
  1469.                         break;
  1470.                 case CAPACITY_NO_CARTRIDGE:
  1471.                         /* This is a KERN_ERR so it appears on screen for the user to see */
  1472.                         printk (KERN_ERR "%s: No disk in driven", drive->name);
  1473.                                         break;
  1474.                 case CAPACITY_INVALID:
  1475.                         printk (KERN_ERR "%s: Invalid capacity for disk in driven", drive->name);
  1476.                                         break;
  1477. }
  1478. }
  1479. if (!i) {
  1480. IDEFLOPPY_DEBUG( "Descriptor 0 Code: %dn", descriptor->dc);
  1481. }
  1482. IDEFLOPPY_DEBUG( "Descriptor %d: %dkB, %d blocks, %d sector sizen", i, blocks * length / 1024, blocks, length);
  1483. }
  1485. /* Clik! disk does not support get_flexible_disk_page */
  1486.         if (!test_bit(IDEFLOPPY_CLIK_DRIVE, &floppy->flags))
  1487. {
  1488. (void) idefloppy_get_flexible_disk_page (drive);
  1489. }
  1491. drive->part[0].nr_sects = floppy->blocks * floppy->bs_factor;
  1492. return rc;
  1493. }
  1495. /*
  1496. ** Obtain the list of formattable capacities.
  1497. ** Very similar to idefloppy_get_capacity, except that we push the capacity
  1498. ** descriptors to userland, instead of our own structures.
  1499. **
  1500. ** Userland gives us the following structure:
  1501. **
  1502. ** struct idefloppy_format_capacities {
  1503. **        int nformats;
  1504. **        struct {
  1505. **                int nblocks;
  1506. **                int blocksize;
  1507. **                } formats[];
  1508. **        } ;
  1509. **
  1510. ** userland initializes nformats to the number of allocated formats[]
  1511. ** records.  On exit we set nformats to the number of records we've
  1512. ** actually initialized.
  1513. **
  1514. */
  1516. static int idefloppy_get_format_capacities (ide_drive_t *drive,
  1517.     struct inode *inode,
  1518.     struct file *file,
  1519.     int *arg) /* Cheater */
  1520. {
  1521.         idefloppy_pc_t pc;
  1522. idefloppy_capacity_header_t *header;
  1523.         idefloppy_capacity_descriptor_t *descriptor;
  1524. int i, descriptors, blocks, length;
  1525. int u_array_size;
  1526. int u_index;
  1527. int *argp;
  1529. if (get_user(u_array_size, arg))
  1530. return (-EFAULT);
  1532. if (u_array_size <= 0)
  1533. return (-EINVAL);
  1535. idefloppy_create_read_capacity_cmd (&pc);
  1536. if (idefloppy_queue_pc_tail (drive, &pc)) {
  1537. printk (KERN_ERR "ide-floppy: Can't get floppy parametersn");
  1538.                 return (-EIO);
  1539.         }
  1540.         header = (idefloppy_capacity_header_t *) pc.buffer;
  1541.         descriptors = header->length /
  1542. sizeof (idefloppy_capacity_descriptor_t);
  1543. descriptor = (idefloppy_capacity_descriptor_t *) (header + 1);
  1545. u_index=0;
  1546. argp=arg+1;
  1548. /*
  1549. ** We always skip the first capacity descriptor.  That's the
  1550. ** current capacity.  We are interested in the remaining descriptors,
  1551. ** the formattable capacities.
  1552. */
  1554. for (i=0; i<descriptors; i++, descriptor++)
  1555. {
  1556. if (u_index >= u_array_size)
  1557. break; /* User-supplied buffer too small */
  1558. if (i == 0)
  1559. continue; /* Skip the first descriptor */
  1561. blocks = ntohl (descriptor->blocks);
  1562. length = ntohs (descriptor->length);
  1564. if (put_user(blocks, argp))
  1565. return (-EFAULT);
  1566. ++argp;
  1568. if (put_user(length, argp))
  1569. return (-EFAULT);
  1570. ++argp;
  1572. ++u_index;
  1573. }
  1575. if (put_user(u_index, arg))
  1576. return (-EFAULT);
  1577. return (0);
  1578. }
  1580. /*
  1581. ** Send ATAPI_FORMAT_UNIT to the drive.
  1582. **
  1583. ** Userland gives us the following structure:
  1584. **
  1585. ** struct idefloppy_format_command {
  1586. **        int nblocks;
  1587. **        int blocksize;
  1588. **        int flags;
  1589. **        } ;
  1590. **
  1591. ** flags is a bitmask, currently, the only defined flag is:
  1592. **
  1593. **        0x01 - verify media after format.
  1594. */
  1596. static int idefloppy_begin_format(ide_drive_t *drive,
  1597.   struct inode *inode,
  1598.   struct file *file,
  1599.   int *arg)
  1600. {
  1601. int blocks;
  1602. int length;
  1603. int flags;
  1604. idefloppy_pc_t pc;
  1606. if (get_user(blocks, arg)
  1607.     || get_user(length, arg+1)
  1608.     || get_user(flags, arg+2))
  1609. {
  1610. return (-EFAULT);
  1611. }
  1613. (void) idefloppy_get_capability_page (drive); /* Get the SFRP bit */
  1614. idefloppy_create_format_unit_cmd(&pc, blocks, length, flags);
  1615. if (idefloppy_queue_pc_tail (drive, &pc))
  1616. {
  1617.                 return (-EIO);
  1618.         }
  1619. return (0);
  1620. }
  1622. /*
  1623. ** Get ATAPI_FORMAT_UNIT progress indication.
  1624. **
  1625. ** Userland gives a pointer to an int.  The int is set to a progresss
  1626. ** indicator 0-65536, with 65536=100%.
  1627. **
  1628. ** If the drive does not support format progress indication, we just check
  1629. ** the dsc bit, and return either 0 or 65536.
  1630. */
  1632. static int idefloppy_get_format_progress(ide_drive_t *drive,
  1633.  struct inode *inode,
  1634.  struct file *file,
  1635.  int *arg)
  1636. {
  1637. idefloppy_floppy_t *floppy = drive->driver_data;
  1638. idefloppy_pc_t pc;
  1639. int progress_indication=0x10000;
  1641. if (floppy->srfp)
  1642. {
  1643. idefloppy_create_request_sense_cmd(&pc);
  1644. if (idefloppy_queue_pc_tail (drive, &pc))
  1645. {
  1646. return (-EIO);
  1647. }
  1649. if (floppy->sense_key == 2 && floppy->asc == 4 &&
  1650.     floppy->ascq == 4)
  1651. {
  1652. progress_indication=floppy->progress_indication;
  1653. }
  1654. /* Else assume format_unit has finished, and we're
  1655. ** at 0x10000 */
  1656. }
  1657. else
  1658. {
  1659. idefloppy_status_reg_t status;
  1660. unsigned long flags;
  1662. __save_flags(flags);
  1663. __cli();
  1664. status.all=GET_STAT();
  1665. __restore_flags(flags);
  1667. progress_indication= !status.b.dsc ? 0:0x10000;
  1668. }
  1669. if (put_user(progress_indication, arg))
  1670. return (-EFAULT);
  1672. return (0);
  1673. }
  1675. /*
  1676.  * Our special ide-floppy ioctl's.
  1677.  *
  1678.  * Currently there aren't any ioctl's.
  1679.  */
  1680. static int idefloppy_ioctl (ide_drive_t *drive, struct inode *inode, struct file *file,
  1681.  unsigned int cmd, unsigned long arg)
  1682. {
  1683. idefloppy_pc_t pc;
  1684. idefloppy_floppy_t *floppy = drive->driver_data;
  1685. int prevent = (arg) ? 1 : 0;
  1687. switch (cmd) {
  1688. case CDROMEJECT:
  1689. prevent = 0;
  1690. /* fall through */
  1691. case CDROM_LOCKDOOR:
  1692. if (drive->usage > 1)
  1693. return -EBUSY;
  1695. /* The IOMEGA Clik! Drive doesn't support this command - no room for an eject mechanism */
  1696.                 if (!test_bit(IDEFLOPPY_CLIK_DRIVE, &floppy->flags)) {
  1697. idefloppy_create_prevent_cmd (&pc, prevent);
  1698. (void) idefloppy_queue_pc_tail (drive, &pc);
  1699. }
  1700. if (cmd == CDROMEJECT) {
  1701. idefloppy_create_start_stop_cmd (&pc, 2);
  1702. (void) idefloppy_queue_pc_tail (drive, &pc);
  1703. }
  1704. return 0;
  1705. case IDEFLOPPY_IOCTL_FORMAT_SUPPORTED:
  1706. return (0);
  1707. case IDEFLOPPY_IOCTL_FORMAT_GET_CAPACITY:
  1708. return (idefloppy_get_format_capacities(drive, inode, file,
  1709. (int *)arg));
  1710. case IDEFLOPPY_IOCTL_FORMAT_START:
  1712. if (!(file->f_mode & 2))
  1713. return (-EPERM);
  1715. {
  1716. idefloppy_floppy_t *floppy = drive->driver_data;
  1718. if (drive->usage > 1)
  1719. {
  1720. /* Don't format if someone is using the disk */
  1722. clear_bit(IDEFLOPPY_FORMAT_IN_PROGRESS,
  1723.   &floppy->flags);
  1724. return -EBUSY;
  1725. }
  1726. else
  1727. {
  1728. int rc;
  1730. set_bit(IDEFLOPPY_FORMAT_IN_PROGRESS,
  1731. &floppy->flags);
  1733. rc=idefloppy_begin_format(drive, inode,
  1734.       file,
  1735.       (int *)arg);
  1737. if (rc)
  1738. clear_bit(IDEFLOPPY_FORMAT_IN_PROGRESS,
  1739.   &floppy->flags);
  1740. return (rc);
  1742. /*
  1743. ** Note, the bit will be cleared when the device is
  1744. ** closed.  This is the cleanest way to handle the
  1745. ** situation where the drive does not support
  1746. ** format progress reporting.
  1747. */
  1748. }
  1749. }
  1750. case IDEFLOPPY_IOCTL_FORMAT_GET_PROGRESS:
  1751. return (idefloppy_get_format_progress(drive, inode, file,
  1752.       (int *)arg));
  1753. }
  1754.   return -EIO;
  1755. }
  1757. /*
  1758.  * Our open/release functions
  1759.  */
  1760. static int idefloppy_open (struct inode *inode, struct file *filp, ide_drive_t *drive)
  1761. {
  1762. idefloppy_floppy_t *floppy = drive->driver_data;
  1763. idefloppy_pc_t pc;
  1765. #if IDEFLOPPY_DEBUG_LOG
  1766. printk (KERN_INFO "Reached idefloppy_openn");
  1767. #endif /* IDEFLOPPY_DEBUG_LOG */
  1769. MOD_INC_USE_COUNT;
  1770. if (drive->usage == 1) {
  1771. clear_bit(IDEFLOPPY_FORMAT_IN_PROGRESS, &floppy->flags);
  1772. /* Just in case */
  1774. idefloppy_create_test_unit_ready_cmd(&pc);
  1775. if (idefloppy_queue_pc_tail(drive, &pc)) {
  1776. idefloppy_create_start_stop_cmd (&pc, 1);
  1777. (void) idefloppy_queue_pc_tail (drive, &pc);
  1778. }
  1780. if (idefloppy_get_capacity (drive)
  1781.    && (filp->f_flags & O_NDELAY) == 0
  1782.     /*
  1783.     ** Allow O_NDELAY to open a drive without a disk, or with
  1784.     ** an unreadable disk, so that we can get the format
  1785.     ** capacity of the drive or begin the format - Sam
  1786.     */
  1787.     ) {
  1788. drive->usage--;
  1789. MOD_DEC_USE_COUNT;
  1790. return -EIO;
  1791. }
  1793. if (floppy->wp && (filp->f_mode & 2)) {
  1794. drive->usage--;
  1795. MOD_DEC_USE_COUNT;
  1796. return -EROFS;
  1797. }
  1798. set_bit (IDEFLOPPY_MEDIA_CHANGED, &floppy->flags);
  1799. /* IOMEGA Clik! drives do not support lock/unlock commands */
  1800.                 if (!test_bit(IDEFLOPPY_CLIK_DRIVE, &floppy->flags)) {
  1801. idefloppy_create_prevent_cmd (&pc, 1);
  1802. (void) idefloppy_queue_pc_tail (drive, &pc);
  1803. }
  1804. check_disk_change(inode->i_rdev);
  1805. }
  1806. else if (test_bit(IDEFLOPPY_FORMAT_IN_PROGRESS, &floppy->flags))
  1807. {
  1808. drive->usage--;
  1809. MOD_DEC_USE_COUNT;
  1810. return -EBUSY;
  1811. }
  1812. return 0;
  1813. }
  1815. static void idefloppy_release (struct inode *inode, struct file *filp, ide_drive_t *drive)
  1816. {
  1817. idefloppy_pc_t pc;
  1819. #if IDEFLOPPY_DEBUG_LOG
  1820. printk (KERN_INFO "Reached idefloppy_releasen");
  1821. #endif /* IDEFLOPPY_DEBUG_LOG */
  1823. if (!drive->usage) {
  1824. idefloppy_floppy_t *floppy = drive->driver_data;
  1826. invalidate_bdev (inode->i_bdev, 0);
  1828. /* IOMEGA Clik! drives do not support lock/unlock commands */
  1829.                 if (!test_bit(IDEFLOPPY_CLIK_DRIVE, &floppy->flags)) {
  1830. idefloppy_create_prevent_cmd (&pc, 0);
  1831. (void) idefloppy_queue_pc_tail (drive, &pc);
  1832. }
  1834. clear_bit(IDEFLOPPY_FORMAT_IN_PROGRESS, &floppy->flags);
  1835. }
  1836. MOD_DEC_USE_COUNT;
  1837. }
  1839. /*
  1840.  * Check media change. Use a simple algorithm for now.
  1841.  */
  1842. static int idefloppy_media_change (ide_drive_t *drive)
  1843. {
  1844. idefloppy_floppy_t *floppy = drive->driver_data;
  1846. return test_and_clear_bit (IDEFLOPPY_MEDIA_CHANGED, &floppy->flags);
  1847. }
  1849. /*
  1850.  * Revalidate the new media. Should set blk_size[]
  1851.  */
  1852. static void idefloppy_revalidate (ide_drive_t *drive)
  1853. {
  1854. grok_partitions(HWIF(drive)->gd, drive->select.b.unit,
  1855. 1<<PARTN_BITS,
  1856. current_capacity(drive));
  1857. }
  1859. /*
  1860.  * Return the current floppy capacity to ide.c.
  1861.  */
  1862. static unsigned long idefloppy_capacity (ide_drive_t *drive)
  1863. {
  1864. idefloppy_floppy_t *floppy = drive->driver_data;
  1865. unsigned long capacity = floppy->blocks * floppy->bs_factor;
  1867. return capacity;
  1868. }
  1870. /*
  1871.  * idefloppy_identify_device checks if we can support a drive,
  1872.  * based on the ATAPI IDENTIFY command results.
  1873.  */
  1874. static int idefloppy_identify_device (ide_drive_t *drive,struct hd_driveid *id)
  1875. {
  1876. struct idefloppy_id_gcw gcw;
  1877. #if IDEFLOPPY_DEBUG_INFO
  1878. unsigned short mask,i;
  1879. char buffer[80];
  1880. #endif /* IDEFLOPPY_DEBUG_INFO */
  1882. *((unsigned short *) &gcw) = id->config;
  1884. #ifdef CONFIG_PPC
  1885. /* kludge for Apple PowerBook internal zip */
  1886. if ((gcw.device_type == 5) && !strstr(id->model, "CD-ROM")
  1887.     && strstr(id->model, "ZIP"))
  1888. gcw.device_type = 0;
  1889. #endif
  1891. #if IDEFLOPPY_DEBUG_INFO
  1892. printk (KERN_INFO "Dumping ATAPI Identify Device floppy parametersn");
  1893. switch (gcw.protocol) {
  1894. case 0: case 1: sprintf (buffer, "ATA");break;
  1895. case 2: sprintf (buffer, "ATAPI");break;
  1896. case 3: sprintf (buffer, "Reserved (Unknown to ide-floppy)");break;
  1897. }
  1898. printk (KERN_INFO "Protocol Type: %sn", buffer);
  1899. switch (gcw.device_type) {
  1900. case 0: sprintf (buffer, "Direct-access Device");break;
  1901. case 1: sprintf (buffer, "Streaming Tape Device");break;
  1902. case 2: case 3: case 4: sprintf (buffer, "Reserved");break;
  1903. case 5: sprintf (buffer, "CD-ROM Device");break;
  1904. case 6: sprintf (buffer, "Reserved");
  1905. case 7: sprintf (buffer, "Optical memory Device");break;
  1906. case 0x1f: sprintf (buffer, "Unknown or no Device type");break;
  1907. default: sprintf (buffer, "Reserved");
  1908. }
  1909. printk (KERN_INFO "Device Type: %x - %sn", gcw.device_type, buffer);
  1910. printk (KERN_INFO "Removable: %sn",gcw.removable ? "Yes":"No");
  1911. switch (gcw.drq_type) {
  1912. case 0: sprintf (buffer, "Microprocessor DRQ");break;
  1913. case 1: sprintf (buffer, "Interrupt DRQ");break;
  1914. case 2: sprintf (buffer, "Accelerated DRQ");break;
  1915. case 3: sprintf (buffer, "Reserved");break;
  1916. }
  1917. printk (KERN_INFO "Command Packet DRQ Type: %sn", buffer);
  1918. switch (gcw.packet_size) {
  1919. case 0: sprintf (buffer, "12 bytes");break;
  1920. case 1: sprintf (buffer, "16 bytes");break;
  1921. default: sprintf (buffer, "Reserved");break;
  1922. }
  1923. printk (KERN_INFO "Command Packet Size: %sn", buffer);
  1924. printk (KERN_INFO "Model: %.40sn",id->model);
  1925. printk (KERN_INFO "Firmware Revision: %.8sn",id->fw_rev);
  1926. printk (KERN_INFO "Serial Number: %.20sn",id->serial_no);
  1927. printk (KERN_INFO "Write buffer size(?): %d bytesn",id->buf_size*512);
  1928. printk (KERN_INFO "DMA: %s",id->capability & 0x01 ? "Yesn":"Non");
  1929. printk (KERN_INFO "LBA: %s",id->capability & 0x02 ? "Yesn":"Non");
  1930. printk (KERN_INFO "IORDY can be disabled: %s",id->capability & 0x04 ? "Yesn":"Non");
  1931. printk (KERN_INFO "IORDY supported: %s",id->capability & 0x08 ? "Yesn":"Unknownn");
  1932. printk (KERN_INFO "ATAPI overlap supported: %s",id->capability & 0x20 ? "Yesn":"Non");
  1933. printk (KERN_INFO "PIO Cycle Timing Category: %dn",id->tPIO);
  1934. printk (KERN_INFO "DMA Cycle Timing Category: %dn",id->tDMA);
  1935. printk (KERN_INFO "Single Word DMA supported modes:n");
  1936. for (i=0,mask=1;i<8;i++,mask=mask << 1) {
  1937. if (id->dma_1word & mask)
  1938. printk (KERN_INFO "   Mode %d%sn", i, (id->dma_1word & (mask << 8)) ? " (active)" : "");
  1939. }
  1940. printk (KERN_INFO "Multi Word DMA supported modes:n");
  1941. for (i=0,mask=1;i<8;i++,mask=mask << 1) {
  1942. if (id->dma_mword & mask)
  1943. printk (KERN_INFO "   Mode %d%sn", i, (id->dma_mword & (mask << 8)) ? " (active)" : "");
  1944. }
  1945. if (id->field_valid & 0x0002) {
  1946. printk (KERN_INFO "Enhanced PIO Modes: %sn",id->eide_pio_modes & 1 ? "Mode 3":"None");
  1947. if (id->eide_dma_min == 0)
  1948. sprintf (buffer, "Not supported");
  1949. else
  1950. sprintf (buffer, "%d ns",id->eide_dma_min);
  1951. printk (KERN_INFO "Minimum Multi-word DMA cycle per word: %sn", buffer);
  1952. if (id->eide_dma_time == 0)
  1953. sprintf (buffer, "Not supported");
  1954. else
  1955. sprintf (buffer, "%d ns",id->eide_dma_time);
  1956. printk (KERN_INFO "Manufacturer's Recommended Multi-word cycle: %sn", buffer);
  1957. if (id->eide_pio == 0)
  1958. sprintf (buffer, "Not supported");
  1959. else
  1960. sprintf (buffer, "%d ns",id->eide_pio);
  1961. printk (KERN_INFO "Minimum PIO cycle without IORDY: %sn", buffer);
  1962. if (id->eide_pio_iordy == 0)
  1963. sprintf (buffer, "Not supported");
  1964. else
  1965. sprintf (buffer, "%d ns",id->eide_pio_iordy);
  1966. printk (KERN_INFO "Minimum PIO cycle with IORDY: %sn", buffer);
  1967. } else
  1968. printk (KERN_INFO "According to the device, fields 64-70 are not valid.n");
  1969. #endif /* IDEFLOPPY_DEBUG_INFO */
  1971. if (gcw.protocol != 2)
  1972. printk (KERN_ERR "ide-floppy: Protocol is not ATAPIn");
  1973. else if (gcw.device_type != 0)
  1974. printk (KERN_ERR "ide-floppy: Device type is not set to floppyn");
  1975. else if (!gcw.removable)
  1976. printk (KERN_ERR "ide-floppy: The removable flag is not setn");
  1977. else if (gcw.drq_type == 3) {
  1978. printk (KERN_ERR "ide-floppy: Sorry, DRQ type %d not supportedn", gcw.drq_type);
  1979. } else if (gcw.packet_size != 0) {
  1980. printk (KERN_ERR "ide-floppy: Packet size is not 12 bytes longn");
  1981. } else
  1982. return 1;
  1983. return 0;
  1984. }
  1986. static void idefloppy_add_settings(ide_drive_t *drive)
  1987. {
  1988. int major = HWIF(drive)->major;
  1989. int minor = drive->select.b.unit << PARTN_BITS;
  1990. idefloppy_floppy_t *floppy = drive->driver_data;
  1992. /*
  1993.  * drive setting name read/write ioctl ioctl data type min max mul_factor div_factor data pointer set function
  1994.  */
  1995. ide_add_setting(drive, "bios_cyl", SETTING_RW, -1, -1, TYPE_INT, 0, 1023, 1, 1, &drive->bios_cyl, NULL);
  1996. ide_add_setting(drive, "bios_head", SETTING_RW, -1, -1, TYPE_BYTE, 0, 255, 1, 1, &drive->bios_head, NULL);
  1997. ide_add_setting(drive, "bios_sect", SETTING_RW, -1, -1, TYPE_BYTE, 0, 63, 1, 1, &drive->bios_sect, NULL);
  1998. ide_add_setting(drive, "breada_readahead", SETTING_RW, BLKRAGET, BLKRASET, TYPE_INT, 0, 255, 1, 2, &read_ahead[major], NULL);
  1999. ide_add_setting(drive, "file_readahead", SETTING_RW, BLKFRAGET, BLKFRASET, TYPE_INTA, 0, INT_MAX, 1, 1024, &max_readahead[major][minor], NULL);
  2000. ide_add_setting(drive, "max_kb_per_request", SETTING_RW, BLKSECTGET, BLKSECTSET, TYPE_INTA, 1, 255, 1, 2, &max_sectors[major][minor], NULL);
  2001. ide_add_setting(drive, "ticks", SETTING_RW, -1, -1, TYPE_BYTE, 0, 255, 1, 1, &floppy->ticks, NULL);
  2003. }
  2005. /*
  2006.  * Driver initialization.
  2007.  */
  2008. static void idefloppy_setup (ide_drive_t *drive, idefloppy_floppy_t *floppy)
  2009. {
  2010. struct idefloppy_id_gcw gcw;
  2011. int major = HWIF(drive)->major, i;
  2012. int minor = drive->select.b.unit << PARTN_BITS;
  2014. *((unsigned short *) &gcw) = drive->id->config;
  2015. drive->driver_data = floppy;
  2016. drive->ready_stat = 0;
  2017. memset (floppy, 0, sizeof (idefloppy_floppy_t));
  2018. floppy->drive = drive;
  2019. floppy->pc = floppy->pc_stack;
  2020. if (gcw.drq_type == 1)
  2021. set_bit (IDEFLOPPY_DRQ_INTERRUPT, &floppy->flags);
  2022. /*
  2023.  * We used to check revisions here. At this point however
  2024.  * I'm giving up. Just assume they are all broken, its easier.
  2025.  *
  2026.  * The actual reason for the workarounds was likely
  2027.  * a driver bug after all rather than a firmware bug,
  2028.  * and the workaround below used to hide it. It should
  2029.  * be fixed as of version 1.9, but to be on the safe side
  2030.  * we'll leave the limitation below for the 2.2.x tree.
  2031.  */
  2033. if (strcmp(drive->id->model, "IOMEGA ZIP 100 ATAPI") == 0)
  2034. {
  2035. set_bit(IDEFLOPPY_ZIP_DRIVE, &floppy->flags);
  2036. /* This value will be visible in the /proc/ide/hdx/settings */
  2037. floppy->ticks = IDEFLOPPY_TICKS_DELAY;
  2038. for (i = 0; i < 1 << PARTN_BITS; i++)
  2039. max_sectors[major][minor + i] = 64;
  2040. }
  2042. /*
  2043. *      Guess what?  The IOMEGA Clik! drive also needs the
  2044. *      above fix.  It makes nasty clicking noises without
  2045. *      it, so please don't remove this.
  2046. */
  2047. if (strncmp(drive->id->model, "IOMEGA Clik!", 11) == 0) 
  2048. {
  2049. for (i = 0; i < 1 << PARTN_BITS; i++)
  2050. max_sectors[major][minor + i] = 64;
  2051. set_bit(IDEFLOPPY_CLIK_DRIVE, &floppy->flags);
  2052. }
  2055. (void) idefloppy_get_capacity (drive);
  2056. idefloppy_add_settings(drive);
  2057. for (i = 0; i < MAX_DRIVES; ++i) {
  2058. ide_hwif_t *hwif = HWIF(drive);
  2060. if (drive != &hwif->drives[i]) continue;
  2061. hwif->gd->de_arr[i] = drive->de;
  2062. if (drive->removable)
  2063. hwif->gd->flags[i] |= GENHD_FL_REMOVABLE;
  2064. break;
  2065. }
  2066. }
  2068. static int idefloppy_cleanup (ide_drive_t *drive)
  2069. {
  2070. idefloppy_floppy_t *floppy = drive->driver_data;
  2072. if (ide_unregister_subdriver (drive))
  2073. return 1;
  2074. drive->driver_data = NULL;
  2075. kfree (floppy);
  2076. return 0;
  2077. }
  2079. #ifdef CONFIG_PROC_FS
  2081. static ide_proc_entry_t idefloppy_proc[] = {
  2082. { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL },
  2083. { NULL, 0, NULL, NULL }
  2084. };
  2086. #else
  2088. #define idefloppy_proc NULL
  2090. #endif /* CONFIG_PROC_FS */
  2092. int idefloppy_reinit(ide_drive_t *drive);
  2094. /*
  2095.  * IDE subdriver functions, registered with ide.c
  2096.  */
  2097. static ide_driver_t idefloppy_driver = {
  2098. name: "ide-floppy",
  2099. version: IDEFLOPPY_VERSION,
  2100. media: ide_floppy,
  2101. busy: 0,
  2102. supports_dma: 1,
  2103. supports_dsc_overlap: 0,
  2104. cleanup: idefloppy_cleanup,
  2105. standby: NULL,
  2106. flushcache: NULL,
  2107. do_request: idefloppy_do_request,
  2108. end_request: idefloppy_end_request,
  2109. ioctl: idefloppy_ioctl,
  2110. open: idefloppy_open,
  2111. release: idefloppy_release,
  2112. media_change: idefloppy_media_change,
  2113. revalidate: idefloppy_revalidate,
  2114. pre_reset: NULL,
  2115. capacity: idefloppy_capacity,
  2116. special: NULL,
  2117. proc: idefloppy_proc,
  2118. reinit: idefloppy_reinit,
  2119. ata_prebuilder: NULL,
  2120. atapi_prebuilder: NULL,
  2121. };
  2123. int idefloppy_init (void);
  2124. static ide_module_t idefloppy_module = {
  2125. IDE_DRIVER_MODULE,
  2126. idefloppy_init,
  2127. &idefloppy_driver,
  2128. NULL
  2129. };
  2131. int idefloppy_reinit (ide_drive_t *drive)
  2132. {
  2133. idefloppy_floppy_t *floppy;
  2134. int failed = 0;
  2136. MOD_INC_USE_COUNT;
  2137. while ((drive = ide_scan_devices (ide_floppy, idefloppy_driver.name, NULL, failed++)) != NULL) {
  2138. if (!idefloppy_identify_device (drive, drive->id)) {
  2139. printk (KERN_ERR "ide-floppy: %s: not supported by this version of ide-floppyn", drive->name);
  2140. continue;
  2141. }
  2142. if (drive->scsi) {
  2143. printk("ide-floppy: passing drive %s to ide-scsi emulation.n", drive->name);
  2144. continue;
  2145. }
  2146. if ((floppy = (idefloppy_floppy_t *) kmalloc (sizeof (idefloppy_floppy_t), GFP_KERNEL)) == NULL) {
  2147. printk (KERN_ERR "ide-floppy: %s: Can't allocate a floppy structuren", drive->name);
  2148. continue;
  2149. }
  2150. if (ide_register_subdriver (drive, &idefloppy_driver, IDE_SUBDRIVER_VERSION)) {
  2151. printk (KERN_ERR "ide-floppy: %s: Failed to register the driver with ide.cn", drive->name);
  2152. kfree (floppy);
  2153. continue;
  2154. }
  2155. DRIVER(drive)->busy++;
  2156. idefloppy_setup (drive, floppy);
  2157. DRIVER(drive)->busy--;
  2158. failed--;
  2159. }
  2160. ide_register_module(&idefloppy_module);
  2161. MOD_DEC_USE_COUNT;
  2162. return 0;
  2163. }
  2165. MODULE_DESCRIPTION("ATAPI FLOPPY Driver");
  2167. static void __exit idefloppy_exit (void)
  2168. {
  2169. ide_drive_t *drive;
  2170. int failed = 0;
  2172. while ((drive = ide_scan_devices (ide_floppy, idefloppy_driver.name, &idefloppy_driver, failed)) != NULL) {
  2173. if (idefloppy_cleanup (drive)) {
  2174. printk ("%s: cleanup_module() called while still busyn", drive->name);
  2175. failed++;
  2176. }
  2177. /* We must remove proc entries defined in this module.
  2178.    Otherwise we oops while accessing these entries */
  2179. #ifdef CONFIG_PROC_FS
  2180. if (drive->proc)
  2181. ide_remove_proc_entries(drive->proc, idefloppy_proc);
  2182. #endif
  2183. }
  2184. ide_unregister_module(&idefloppy_module);
  2185. }
  2187. /*
  2188.  * idefloppy_init will register the driver for each floppy.
  2189.  */
  2190. int idefloppy_init (void)
  2191. {
  2192. ide_drive_t *drive;
  2193. idefloppy_floppy_t *floppy;
  2194. int failed = 0;
  2196. printk("ide-floppy driver " IDEFLOPPY_VERSION "n");
  2197. MOD_INC_USE_COUNT;
  2198. while ((drive = ide_scan_devices (ide_floppy, idefloppy_driver.name, NULL, failed++)) != NULL) {
  2199. if (!idefloppy_identify_device (drive, drive->id)) {
  2200. printk (KERN_ERR "ide-floppy: %s: not supported by this version of ide-floppyn", drive->name);
  2201. continue;
  2202. }
  2203. if (drive->scsi) {
  2204. printk("ide-floppy: passing drive %s to ide-scsi emulation.n", drive->name);
  2205. continue;
  2206. }
  2207. if ((floppy = (idefloppy_floppy_t *) kmalloc (sizeof (idefloppy_floppy_t), GFP_KERNEL)) == NULL) {
  2208. printk (KERN_ERR "ide-floppy: %s: Can't allocate a floppy structuren", drive->name);
  2209. continue;
  2210. }
  2211. if (ide_register_subdriver (drive, &idefloppy_driver, IDE_SUBDRIVER_VERSION)) {
  2212. printk (KERN_ERR "ide-floppy: %s: Failed to register the driver with ide.cn", drive->name);
  2213. kfree (floppy);
  2214. continue;
  2215. }
  2216. DRIVER(drive)->busy++;
  2217. idefloppy_setup (drive, floppy);
  2218. DRIVER(drive)->busy--;
  2219. failed--;
  2220. }
  2221. ide_register_module(&idefloppy_module);
  2222. MOD_DEC_USE_COUNT;
  2223. return 0;
  2224. }
  2226. module_init(idefloppy_init);
  2227. module_exit(idefloppy_exit);
  2228. MODULE_LICENSE("GPL");