home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 4 / DATAFILE_PDCD4.iso / unix / riscbsd / sources / patches / netbsd / atapidir_p / atapidir.patch
Encoding:
Text File  |  1996-06-14  |  65.9 KB  |  2,357 lines
  1. diff -c -r -N --exclude exp --exclude compile sys/atapi.orig/acd.c sys/atapi/acd.c
  2. *** sys/atapi.orig/acd.c    Thu Jan  1 01:00:00 1970
  3. --- sys/atapi/acd.c    Thu Jun 13 03:19:49 1996
  4. ***************
  5. *** 0 ****
  6. --- 1,1294 ----
  7. + /*
  8. +  * Copyright (c) 1996 Manuel Bouyer.  All rights reserved.
  9. +  *
  10. +  * Redistribution and use in source and binary forms, with or without
  11. +  * modification, are permitted provided that the following conditions
  12. +  * are met:
  13. +  * 1. Redistributions of source code must retain the above copyright
  14. +  *    notice, this list of conditions and the following disclaimer.
  15. +  * 2. Redistributions in binary form must reproduce the above copyright
  16. +  *    notice, this list of conditions and the following disclaimer in the
  17. +  *    documentation and/or other materials provided with the distribution.
  18. +  * 3. All advertising materials mentioning features or use of this software
  19. +  *    must display the following acknowledgement:
  20. +  *  This product includes software developed by Manuel Bouyer.
  21. +  * 4. The name of the author may not be used to endorse or promote products
  22. +  *    derived from this software without specific prior written permission.
  23. +  *
  24. +  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  25. +  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  26. +  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  27. +  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  28. +  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  29. +  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  30. +  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  31. +  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  32. +  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  33. +  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34. +  */
  35. + 
  36. + 
  37. + #include <sys/types.h>
  38. + #include <sys/param.h>
  39. + #include <sys/systm.h>
  40. + #include <sys/kernel.h>
  41. + #include <sys/conf.h>
  42. + #include <sys/file.h>
  43. + #include <sys/stat.h>
  44. + #include <sys/ioctl.h>
  45. + #include <sys/buf.h>
  46. + #include <sys/uio.h>
  47. + #include <sys/malloc.h>
  48. + #include <sys/errno.h>
  49. + #include <sys/device.h>
  50. + #include <sys/disklabel.h>
  51. + #include <sys/disk.h>
  52. + #include <sys/cdio.h>
  53. + #include <sys/proc.h>  
  54. + 
  55. + #include <atapi/atapilink.h>
  56. + #include <atapi/atapi.h>
  57. + 
  58. + #define    CDUNIT(z)            DISKUNIT(z)
  59. + #define    CDPART(z)            DISKPART(z)
  60. + #define    MAKECDDEV(maj, unit, part)    MAKEDISKDEV(maj, unit, part)
  61. + 
  62. + struct acd_softc {
  63. +     struct device sc_dev;
  64. +     struct disk sc_dk;
  65. + 
  66. +     int flags;
  67. + #define    CDF_LOCKED    0x01
  68. + #define    CDF_WANTED    0x02
  69. + #define    CDF_WLABEL    0x04        /* label is writable */
  70. + #define    CDF_LABELLING    0x08        /* writing label */
  71. +     struct at_dev_link *ad_link;    /* contains our drive number, etc ... */
  72. +     struct cd_parms {
  73. +         int blksize;
  74. +         u_long disksize;    /* total number sectors */
  75. +     } params;
  76. +     struct buf buf_queue;
  77. + };
  78. + 
  79. + int acdmatch __P((struct device *, void *, void *));
  80. + void acdattach __P((struct device *, struct device *, void *));
  81. + 
  82. + struct cfattach acd_ca = {
  83. +     sizeof(struct acd_softc), acdmatch, acdattach
  84. + };
  85. + 
  86. + struct cfdriver acd_cd = {
  87. +     NULL, "acd", DV_DISK
  88. + };
  89. + 
  90. + void acdgetdisklabel __P((struct acd_softc *));
  91. + int acd_get_parms __P((struct acd_softc *, int));
  92. + void acdstrategy __P((struct buf *));
  93. + void acdstart __P((struct acd_softc *));
  94. + int acd_pause __P((struct acd_softc *, int));
  95. + void    acdminphys __P((struct buf*));
  96. + u_long acd_size __P((struct acd_softc*, int));
  97. + int acddone __P((struct atapi_command_packet *));
  98. + int acd_reset __P((struct acd_softc *acd));
  99. + 
  100. + struct dkdriver acddkdriver = { acdstrategy };
  101. + 
  102. + int
  103. + acdmatch(parent, match, aux)
  104. +     struct device *parent;
  105. +     void *match, *aux;
  106. + {
  107. + /*    struct cfdata *cf = match;*/
  108. +     struct at_dev_link *sa = aux;
  109. + #ifdef ATAPI_DEBUG_PROBE
  110. +     printf("acdmatch: device %d\n",sa->id.config.device_type);
  111. + #endif
  112. +     if (sa->id.config.device_type == ATAPI_DEVICE_TYPE_CD) return 1;
  113. +     return 0;
  114. +     
  115. + }
  116. + 
  117. + /*
  118. +  * The routine called by the low level atapi routine when it discovers
  119. +  * A device suitable for this driver
  120. +  */
  121. + void
  122. + acdattach(parent, self, aux)
  123. +     struct device *parent, *self;
  124. +     void *aux;
  125. + {
  126. +     struct acd_softc *acd = (void *)self;
  127. +     struct at_dev_link *sa = aux;
  128. +     struct mode_sense cmd;
  129. +     struct cappage cap;
  130. + 
  131. +     sa->device_softc = acd;
  132. +     sa->start = acdstart;
  133. +     sa->done = acddone;
  134. +     sa->flags |= ADEV_REMOVABLE;
  135. +     sa->openings = 1;
  136. +     acd->ad_link = sa;
  137. + 
  138. +     /*
  139. +      * Initialize and attach the disk structure.
  140. +      */
  141. +     acd->sc_dk.dk_driver = &acddkdriver;
  142. +     acd->sc_dk.dk_name = acd->sc_dev.dv_xname;
  143. +     disk_attach(&acd->sc_dk);
  144. + 
  145. + #if !defined(i386) || defined(NEWCONFIG)
  146. +     dk_establish(&acd->sc_dk, &acd->sc_dev);   
  147. + #endif
  148. + 
  149. +     (void)atapi_test_unit_ready(sa, A_POLLED | A_SILENT); 
  150. +     delay(1000);
  151. +     (void)atapi_test_unit_ready(sa, A_POLLED | A_SILENT);
  152. +                                         /* To clear media change, etc ...*/
  153. +     bzero(&cmd, sizeof(cmd));
  154. +     cmd.operation_code = ATAPI_MODE_SENSE;
  155. +     cmd.page_code = CAP_PAGE;
  156. +     cmd.length[0] = sizeof (cap) >> 8;
  157. +     cmd.length[1] = sizeof (cap);
  158. +     if (atapi_exec_cmd(sa, &cmd , sizeof(cmd), &cap, sizeof(cap),
  159. +         B_READ, A_POLLED) != 0) {
  160. +         printf("atapi_exec_cmd failed\n");
  161. +         return;
  162. +     }
  163. +     switch (cap.medium_type) {
  164. +         case MDT_UNKNOWN:   printf ("medium type unknown");
  165. +                             break;
  166. +         case MDT_DATA_120:  printf ("120mm data disc ");
  167. +                             break;
  168. +         case MDT_AUDIO_120: printf ("120mm audio disc ");
  169. +                             break;
  170. +         case MDT_COMB_120:  printf ("120mm data/audio disc ");
  171. +                             break;
  172. +         case MDT_PHOTO_120: printf ("120mm photo disc ");
  173. +                             break;
  174. +         case MDT_DATA_80:   printf ("80mm data disc ");
  175. +                             break;
  176. +         case MDT_AUDIO_80:  printf ("80mm audio disc ");
  177. +                             break;
  178. +         case MDT_COMB_80:   printf ("80mm data/audio disc ");
  179. +                             break;
  180. +         case MDT_PHOTO_80:  printf ("80mm photo disc ");
  181. +                             break;
  182. +         case MDT_NO_DISC:   printf ("drive empty ");
  183. +                             break;
  184. +         case MDT_DOOR_OPEN: printf ("door open");
  185. +                             break;
  186. +         case MDT_FMT_ERROR: printf ("medium format error");
  187. +                             break;
  188. +         default:    printf ("unknown medium type=0x%x", cap.medium_type);
  189. +                     break;
  190. +     }
  191. +     printf("\n");
  192. + 
  193. + }
  194. + 
  195. + /*
  196. +  * Wait interruptibly for an exclusive lock.
  197. +  *
  198. +  * XXX
  199. +  * Several drivers do this; it should be abstracted and made MP-safe.
  200. +  */
  201. + int
  202. + acdlock(acd)
  203. +     struct acd_softc *acd;
  204. + {
  205. +     int error;
  206. + 
  207. +     while ((acd->flags & CDF_LOCKED) != 0) {
  208. +         acd->flags |= CDF_WANTED;
  209. +         if ((error = tsleep(acd, PRIBIO | PCATCH, "acdlck", 0)) != 0)
  210. +             return error;
  211. +     }
  212. +     acd->flags |= CDF_LOCKED;
  213. +     return 0;
  214. + }
  215. + 
  216. + /*
  217. +  * Unlock and wake up any waiters.
  218. +  */
  219. + void
  220. + acdunlock(acd)
  221. +     struct acd_softc *acd;
  222. + {
  223. + 
  224. +     acd->flags &= ~CDF_LOCKED;
  225. +     if ((acd->flags & CDF_WANTED) != 0) {
  226. +         acd->flags &= ~CDF_WANTED;
  227. +         wakeup(acd);
  228. +     }
  229. + }
  230. + 
  231. + /*
  232. +  * open the device. Make sure the partition info is a up-to-date as can be.
  233. +  */
  234. + int
  235. + acdopen(dev, flag, fmt)
  236. +     dev_t dev;
  237. +     int flag, fmt;
  238. + {
  239. +     struct acd_softc *acd;
  240. +     struct at_dev_link *ad_link;
  241. +     int unit, part;
  242. +     int error;
  243. + 
  244. + #ifdef ACD_DEBUG
  245. +     printf("acd: open\n");
  246. + #endif
  247. + 
  248. +     unit = CDUNIT(dev);
  249. +     if (unit >= acd_cd.cd_ndevs)
  250. +         return ENXIO;
  251. +     acd = acd_cd.cd_devs[unit];
  252. +     if (!acd)
  253. +         return ENXIO;
  254. + 
  255. +     ad_link = acd->ad_link;
  256. + 
  257. +     if ((error = atapi_test_unit_ready(ad_link,0)) != 0) {
  258. +         if (error != UNIT_ATTENTION) return EIO;
  259. +         if ((ad_link->flags & ADEV_OPEN) != 0 ) return EIO;
  260. +     }
  261. + 
  262. +     if ((error = acdlock(acd)))
  263. +         return error;
  264. + 
  265. +     if (acd->sc_dk.dk_openmask != 0) {
  266. +         /*
  267. +          * If any partition is open, but the disk has been invalidated,
  268. +          * disallow further opens.
  269. +          */
  270. +         if ((ad_link->flags & ADEV_MEDIA_LOADED) == 0) {
  271. +             error = EIO;
  272. +             goto bad3;
  273. +         }
  274. +     } else {
  275. +         ad_link->flags |= ADEV_OPEN;
  276. + 
  277. +         /* Lock the pack in. */
  278. +         if ((error = atapi_prevent(ad_link, PR_PREVENT)))
  279. +             goto bad;
  280. + 
  281. +         if ((ad_link->flags & ADEV_MEDIA_LOADED) == 0) {
  282. +             ad_link->flags |= ADEV_MEDIA_LOADED;
  283. + 
  284. +             /* Load the physical device parameters. */
  285. +             if (acd_get_parms(acd, 0) != 0) {
  286. +                 error = ENXIO;
  287. +                 goto bad2;
  288. +             }
  289. + 
  290. +             /* Fabricate a disk label. */
  291. +             acdgetdisklabel(acd);
  292. +         }
  293. +     }
  294. + 
  295. +     part = CDPART(dev);
  296. + 
  297. +     /* Check that the partition exists. */
  298. +     if (part != RAW_PART &&
  299. +         (part >= acd->sc_dk.dk_label->d_npartitions ||
  300. +          acd->sc_dk.dk_label->d_partitions[part].p_fstype == FS_UNUSED)) {
  301. +         error = ENXIO;
  302. +         goto bad;
  303. +     }
  304. + 
  305. +     /* Insure only one open at a time. */
  306. +     switch (fmt) {
  307. +     case S_IFCHR:
  308. +         acd->sc_dk.dk_copenmask |= (1 << part);
  309. +         break;
  310. +     case S_IFBLK:
  311. +         acd->sc_dk.dk_bopenmask |= (1 << part);
  312. +         break;
  313. +     }
  314. +     acd->sc_dk.dk_openmask = acd->sc_dk.dk_copenmask | acd->sc_dk.dk_bopenmask;
  315. + #ifdef ACD_DEBUG
  316. +     printf("open complete\n");
  317. + #endif
  318. +     acdunlock(acd);
  319. +     return 0;
  320. + 
  321. + bad2:
  322. +     ad_link->flags &= ~ADEV_MEDIA_LOADED;
  323. + 
  324. + bad:
  325. +     if (acd->sc_dk.dk_openmask == 0) {
  326. +         atapi_prevent(ad_link, PR_ALLOW);
  327. +         ad_link->flags &= ~ADEV_OPEN;
  328. +     }
  329. + 
  330. + bad3:
  331. +     acdunlock(acd);
  332. +     return error;
  333. + }
  334. + 
  335. + /*
  336. +  * close the device.. only called if we are the LAST
  337. +  * occurence of an open device
  338. +  */
  339. + int
  340. + acdclose(dev, flag, fmt)
  341. +     dev_t dev;
  342. +     int flag, fmt;
  343. + {
  344. +     struct acd_softc *acd = acd_cd.cd_devs[CDUNIT(dev)];
  345. +     int part = CDPART(dev);
  346. +     int error;
  347. + 
  348. +     if ((error = acdlock(acd)))
  349. +         return error;
  350. + 
  351. +     switch (fmt) {
  352. +     case S_IFCHR:
  353. +         acd->sc_dk.dk_copenmask &= ~(1 << part);
  354. +         break;
  355. +     case S_IFBLK:
  356. +         acd->sc_dk.dk_bopenmask &= ~(1 << part);
  357. +         break;
  358. +     }
  359. +     acd->sc_dk.dk_openmask = acd->sc_dk.dk_copenmask | acd->sc_dk.dk_bopenmask;
  360. + 
  361. +     if (acd->sc_dk.dk_openmask == 0) {
  362. +         /* XXXX Must wait for I/O to complete! */
  363. + 
  364. +         atapi_prevent(acd->ad_link, PR_ALLOW);
  365. +         acd->ad_link->flags &= ~ADEV_OPEN;
  366. +     }
  367. + 
  368. +     acdunlock(acd);
  369. +     return 0;
  370. + }
  371. + 
  372. + /*
  373. +  * Actually translate the requested transfer into one the physical driver can
  374. +  * understand.  The transfer is described by a buf and will include only one
  375. +  * physical transfer.
  376. +  */
  377. + void
  378. + acdstrategy(bp)
  379. +     struct buf *bp;
  380. + {
  381. +     struct acd_softc *acd = acd_cd.cd_devs[CDUNIT(bp->b_dev)];
  382. +     int opri;
  383. + 
  384. + #ifdef ACD_DEBUG
  385. +     printf("acdstrategy\n");
  386. + #endif
  387. + 
  388. +     /*
  389. +      * The transfer must be a whole number of blocks.
  390. +      */
  391. +     if ((bp->b_bcount % acd->sc_dk.dk_label->d_secsize) != 0) {
  392. +         bp->b_error = EINVAL;
  393. +         goto bad;
  394. +     }
  395. +     if ((bp->b_flags & (B_READ|B_WRITE)) == B_WRITE) {
  396. +         bp->b_error = EROFS;
  397. +         goto bad;
  398. +     }
  399. +     /*
  400. +      * If the device has been made invalid, error out
  401. +      * maybe the media changed
  402. +      */
  403. +     if ((acd->ad_link->flags & ADEV_MEDIA_LOADED) == 0) {
  404. +         bp->b_error = EIO;
  405. +         goto bad;
  406. +     }
  407. +     /*
  408. +      * If it's a null transfer, return immediately
  409. +      */
  410. +     if (bp->b_bcount == 0)
  411. +         goto done;
  412. + 
  413. +     /*
  414. +      * Do bounds checking, adjust transfer. if error, process.
  415. +      * If end of partition, just return.
  416. +      */
  417. +     if (CDPART(bp->b_dev) != RAW_PART &&
  418. +         bounds_check_with_label(bp, acd->sc_dk.dk_label,
  419. +         (acd->flags & (CDF_WLABEL|CDF_LABELLING)) != 0) <= 0)
  420. +         goto done;
  421. + 
  422. +     opri = splbio();
  423. + 
  424. +     /*
  425. +      * Place it in the queue of disk activities for this disk
  426. +      */
  427. +     disksort(&acd->buf_queue, bp);
  428. + 
  429. +     /*
  430. +      * Tell the device to get going on the transfer if it's
  431. +      * not doing anything, otherwise just wait for completion
  432. +      */
  433. +     acdstart(acd);
  434. + 
  435. +     splx(opri);
  436. +     return;
  437. + 
  438. + bad:
  439. +     bp->b_flags |= B_ERROR;
  440. + done:
  441. +     /*
  442. +      * Correctly set the buf to indicate a completed xfer
  443. +      */
  444. +     bp->b_resid = bp->b_bcount;
  445. +     biodone(bp);
  446. + }
  447. + 
  448. + /*
  449. +  * acdstart looks to see if there is a buf waiting for the device
  450. +  * and that the device is not already busy. If both are true,
  451. +  * It deques the buf and creates a atapi command to perform the
  452. +  * transfer in the buf. The transfer request will call atapi_done
  453. +  * on completion, which will in turn call this routine again
  454. +  * so that the next queued transfer is performed.
  455. +  * The bufs are queued by the strategy routine (cdstrategy)
  456. +  *
  457. +  * This routine is also called after other non-queued requests
  458. +  * have been made of the atapi driver, to ensure that the queue
  459. +  * continues to be drained.
  460. +  *
  461. +  * must be called at the correct (highish) spl level
  462. +  * cdstart() is called at splbio from cdstrategy and atapi_done
  463. +  */
  464. + void
  465. + acdstart(acd)
  466. +     struct acd_softc *acd;
  467. + {
  468. +     struct at_dev_link *ad_link;
  469. +     struct buf *bp = 0;
  470. +     struct buf *dp;
  471. +     struct read cmd;
  472. +     u_int32_t blkno, nblks;
  473. +     struct partition *p;
  474. + 
  475. + #ifdef ACD_DEBUG
  476. +     printf("acd: acdstart\n");
  477. +     if (acd == NULL) {
  478. +         printf("acdstart: null acd\n");
  479. +         return;
  480. +     }
  481. + #endif
  482. +         
  483. +     ad_link = acd->ad_link;
  484. + #ifdef ACD_DEBUG
  485. +     if (ad_link == NULL) {
  486. +         printf("acdstart: null ad_link\n");
  487. +         return;
  488. +     }
  489. + #endif
  490. +     /*
  491. +      * Check if the device has room for another command
  492. +      */
  493. +     while (ad_link->openings >0 ) {
  494. +         /*
  495. +          * there is excess capacity, but a special waits
  496. +          * It'll need the adapter as soon as we clear out of the
  497. +          * way and let it run (user level wait).
  498. +          */
  499. +         if (ad_link->flags & ADEV_WAITING) {
  500. + #ifdef ATAPI_DEBUG
  501. +             printf("acdstart: waking up\n");
  502. + #endif
  503. +             ad_link->flags &= ~ADEV_WAITING;
  504. +             wakeup((caddr_t)ad_link);
  505. +             return;
  506. +         }
  507. +         
  508. +         /*
  509. +          * See if there is a buf with work for us to do..
  510. +          */
  511. +         dp = &acd->buf_queue;
  512. + #ifdef ACD_DEBUG
  513. +         if (dp == NULL) {
  514. +             printf("acdstart: null dp\n");
  515. +             return;
  516. +         }
  517. + #endif
  518. +         if ((bp = dp->b_actf) == NULL)    /* yes, an assign */
  519. +             return;
  520. + #ifdef ACD_DEBUG
  521. +         printf("acdstart: a buf\n");
  522. + #endif
  523. +         dp->b_actf = bp->b_actf;
  524. + 
  525. +         /*
  526. +          * If the device has become invalid, abort all the
  527. +          * reads and writes until all files have been closed and
  528. +          * re-opened
  529. +          */
  530. +         if ((ad_link->flags & ADEV_MEDIA_LOADED) == 0) {
  531. +             bp->b_error = EIO;
  532. +             bp->b_flags |= B_ERROR;
  533. +             biodone(bp);
  534. +             continue;
  535. +         }
  536. + 
  537. +         /*
  538. +          *
  539. +          * First, translate the block to absolute and put it in terms
  540. +          * of the logical blocksize of the device.
  541. +          */
  542. +         blkno =
  543. +             bp->b_blkno / (acd->sc_dk.dk_label->d_secsize / DEV_BSIZE);
  544. +         if (CDPART(bp->b_dev) != RAW_PART) {
  545. +             p = &acd->sc_dk.dk_label->d_partitions[CDPART(bp->b_dev)];
  546. +             blkno += p->p_offset;
  547. +         }
  548. +         nblks = howmany(bp->b_bcount, acd->sc_dk.dk_label->d_secsize);
  549. + #ifdef ACD_DEBUG
  550. +         printf("acdstart: blkno %d nblk %d\n",blkno, nblks);
  551. + #endif
  552. + 
  553. +         /*
  554. +          *  Fill out the atapi command
  555. +          */
  556. +         bzero(&cmd, sizeof(cmd));
  557. +         cmd.operation_code = ATAPI_READ;
  558. +         cmd.lba[0] = (blkno >> 24) & 0xff;
  559. +         cmd.lba[1] = (blkno >> 16) & 0xff;
  560. +         cmd.lba[2] = (blkno >> 8) & 0xff;
  561. +         cmd.lba[3] = blkno & 0xff;
  562. +         cmd.length[0] = (nblks >> 8) & 0xff;
  563. +         cmd.length[1] = nblks & 0xff;
  564. + 
  565. +         /* Instrumentation. */
  566. +         disk_busy(&acd->sc_dk);
  567. + 
  568. +         /*
  569. +          * Call the routine that chats with the adapter.
  570. +          * Note: we cannot sleep as we may be an interrupt
  571. +          */
  572. + 
  573. +          if (atapi_exec_io(ad_link, &cmd, sizeof(cmd), bp, A_NOSLEEP))
  574. +             printf("%s: not queued", acd->sc_dev.dv_xname);
  575. +     }
  576. + }
  577. + 
  578. + int
  579. + acdread(dev, uio)
  580. +     dev_t dev;
  581. +     struct uio *uio;
  582. + {
  583. + 
  584. +     return (physio(acdstrategy, NULL, dev, B_READ,
  585. +                acdminphys, uio));
  586. + }
  587. + 
  588. + int
  589. + acdwrite(dev, uio)
  590. +     dev_t dev;
  591. +     struct uio *uio;
  592. + {
  593. + 
  594. +     return (physio(acdstrategy, NULL, dev, B_WRITE,
  595. +                acdminphys, uio));
  596. + }
  597. + 
  598. + /*
  599. +  * Perform special action on behalf of the user.
  600. +  * Knows about the internals of this device
  601. +  */
  602. + int
  603. + acdioctl(dev, cmd, addr, flag, p)
  604. +     dev_t dev;
  605. +     u_long cmd;
  606. +     caddr_t addr;
  607. +     int flag;
  608. +     struct proc *p;
  609. + {
  610. +     struct acd_softc *acd = acd_cd.cd_devs[CDUNIT(dev)];
  611. +     int error;
  612. + 
  613. +     /*
  614. +      * If the device is not valid.. abandon ship
  615. +      */
  616. +     if ((acd->ad_link->flags & ADEV_MEDIA_LOADED) == 0)
  617. +         return EIO;
  618. + 
  619. +     switch (cmd) {
  620. +     case DIOCGDINFO:
  621. +         *(struct disklabel *)addr = *acd->sc_dk.dk_label;
  622. +         return 0;
  623. + 
  624. +     case DIOCGPART:
  625. +         ((struct partinfo *)addr)->disklab = acd->sc_dk.dk_label;
  626. +         ((struct partinfo *)addr)->part =
  627. +             &acd->sc_dk.dk_label->d_partitions[CDPART(dev)];
  628. +         return 0;
  629. + 
  630. +     case DIOCWDINFO:
  631. +     case DIOCSDINFO:
  632. +         if ((flag & FWRITE) == 0)
  633. +             return EBADF;
  634. + 
  635. +         if ((error = acdlock(acd)))
  636. +             return error;
  637. +         acd->flags |= CDF_LABELLING;
  638. + 
  639. +         error = setdisklabel(acd->sc_dk.dk_label,
  640. +             (struct disklabel *)addr, /*acd->sc_dk.dk_openmask : */0,
  641. +             acd->sc_dk.dk_cpulabel);
  642. +         if (error == 0) {
  643. +         }
  644. + 
  645. +         acd->flags &= ~CDF_LABELLING;
  646. +         acdunlock(acd);
  647. +         return error;
  648. + 
  649. +     case DIOCWLABEL:
  650. +         return EBADF;
  651. + 
  652. +     case CDIOCPLAYTRACKS:
  653. + #ifdef notyet
  654. +         {
  655. +         struct ioc_play_track *args = (struct ioc_play_track *)addr;
  656. +         struct acd_mode_data data;
  657. +         if (error = acd_get_mode(acd, &data, AUDIO_PAGE))
  658. +             return error;
  659. +         data.page.audio.flags &= ~CD_PA_SOTC;
  660. +         data.page.audio.flags |= CD_PA_IMMED;
  661. +         if (error = acd_set_mode(acd, &data))
  662. +             return error;
  663. +         return acd_play_tracks(acd, args->start_track, args->start_index,
  664. +             args->end_track, args->end_index);
  665. +     }
  666. + #else
  667. +     return ENOTTY;
  668. + #endif
  669. +     case CDIOCPLAYMSF:
  670. + #ifdef notyet
  671. +         {
  672. +         struct ioc_play_msf *args
  673. +         = (struct ioc_play_msf *)addr;
  674. +         struct cd_mode_data data;
  675. +         if (error = cd_get_mode(cd, &data, AUDIO_PAGE))
  676. +             return error;
  677. +         data.page.audio.flags &= ~CD_PA_SOTC;
  678. +         data.page.audio.flags |= CD_PA_IMMED;
  679. +         if (error = cd_set_mode(cd, &data))
  680. +             return error;
  681. +         return cd_play_msf(cd, args->start_m, args->start_s,
  682. +             args->start_f, args->end_m, args->end_s, args->end_f);
  683. +     }
  684. + #else
  685. +     return ENOTTY; 
  686. + #endif
  687. +     case CDIOCPLAYBLOCKS:
  688. + #ifdef notyet
  689. +     {
  690. +         struct ioc_play_blocks *args
  691. +         = (struct ioc_play_blocks *)addr;
  692. +         struct cd_mode_data data;
  693. +         if (error = cd_get_mode(cd, &data, AUDIO_PAGE))
  694. +             return error;
  695. +         data.page.audio.flags &= ~CD_PA_SOTC;
  696. +         data.page.audio.flags |= CD_PA_IMMED;
  697. +         if (error = cd_set_mode(cd, &data))
  698. +             return error;
  699. +         return cd_play(cd, args->blk, args->len);
  700. +     }
  701. + #else
  702. +     return ENOTTY; 
  703. + #endif
  704. +     case CDIOCREADSUBCHANNEL:
  705. + #ifdef notyet 
  706. +     {
  707. +         struct ioc_read_subchannel *args
  708. +         = (struct ioc_read_subchannel *)addr;
  709. +         struct cd_sub_channel_info data;
  710. +         int len = args->data_len;
  711. +         if (len > sizeof(data) ||
  712. +             len < sizeof(struct cd_sub_channel_header))
  713. +             return EINVAL;
  714. +         if (error = cd_read_subchannel(cd, args->address_format,
  715. +             args->data_format, args->track, &data, len))
  716. +             return error;
  717. +         len = min(len, ((data.header.data_len[0] << 8) +
  718. +             data.header.data_len[1] +
  719. +             sizeof(struct cd_sub_channel_header)));
  720. +         return copyout(&data, args->data, len);
  721. +     }
  722. + #else
  723. +     return ENOTTY; 
  724. + #endif
  725. +     case CDIOREADTOCHEADER:
  726. + #ifdef notyet
  727. +     {
  728. +         struct ioc_toc_header th;
  729. +         if (error = cd_read_toc(cd, 0, 0, &th, sizeof(th)))
  730. +             return error;
  731. +         th.len = ntohs(th.len);
  732. +         bcopy(&th, addr, sizeof(th));
  733. +         return 0;
  734. +     }
  735. + #else
  736. +     return ENOTTY; 
  737. + #endif
  738. +     case CDIOREADTOCENTRYS:
  739. + #ifdef notyet
  740. +     {
  741. +         struct cd_toc {
  742. +             struct ioc_toc_header header;
  743. +             struct cd_toc_entry entries[65];
  744. +         } data;
  745. +         struct ioc_read_toc_entry *te =
  746. +         (struct ioc_read_toc_entry *)addr;
  747. +         struct ioc_toc_header *th;
  748. +         int len = te->data_len;
  749. +         th = &data.header;
  750. + 
  751. +         if (len > sizeof(data.entries) ||
  752. +             len < sizeof(struct cd_toc_entry))
  753. +             return EINVAL;
  754. +         if (error = cd_read_toc(cd, te->address_format,
  755. +             te->starting_track, (struct cd_toc_entry *)&data,
  756. +             len + sizeof(struct ioc_toc_header)))
  757. +             return error;
  758. +         len = min(len, ntohs(th->len) - (sizeof(th->starting_track) +
  759. +             sizeof(th->ending_track)));
  760. +         return copyout(data.entries, te->data, len);
  761. +     }
  762. + #else
  763. +     return ENOTTY; 
  764. + #endif
  765. +     case CDIOCSETPATCH:
  766. + #ifdef notyet
  767. + {
  768. +         struct ioc_patch *arg = (struct ioc_patch *)addr;
  769. +         struct cd_mode_data data;
  770. +         if (error = cd_get_mode(cd, &data, AUDIO_PAGE))
  771. +             return error;
  772. +         data.page.audio.port[LEFT_PORT].channels = arg->patch[0];
  773. +         data.page.audio.port[RIGHT_PORT].channels = arg->patch[1];
  774. +         data.page.audio.port[2].channels = arg->patch[2];
  775. +         data.page.audio.port[3].channels = arg->patch[3];
  776. +         return cd_set_mode(cd, &data);
  777. +     }
  778. + #else
  779. +     return ENOTTY; 
  780. + #endif
  781. +     case CDIOCGETVOL:
  782. + #ifdef notyet
  783. +     {
  784. +         struct ioc_vol *arg = (struct ioc_vol *)addr;
  785. +         struct cd_mode_data data;
  786. +         if (error = cd_get_mode(cd, &data, AUDIO_PAGE))
  787. +             return error;
  788. +         arg->vol[LEFT_PORT] = data.page.audio.port[LEFT_PORT].volume;
  789. +         arg->vol[RIGHT_PORT] = data.page.audio.port[RIGHT_PORT].volume;
  790. +         arg->vol[2] = data.page.audio.port[2].volume;
  791. +         arg->vol[3] = data.page.audio.port[3].volume;
  792. +         return 0;
  793. +     }
  794. + #else
  795. +     return ENOTTY; 
  796. + #endif
  797. +     case CDIOCSETVOL:
  798. + #ifdef notyet
  799. + {
  800. +         struct ioc_vol *arg = (struct ioc_vol *)addr;
  801. +         struct cd_mode_data data;
  802. +         if (error = cd_get_mode(cd, &data, AUDIO_PAGE))
  803. +             return error;
  804. +         data.page.audio.port[LEFT_PORT].channels = CHANNEL_0;
  805. +         data.page.audio.port[LEFT_PORT].volume = arg->vol[LEFT_PORT];
  806. +         data.page.audio.port[RIGHT_PORT].channels = CHANNEL_1;
  807. +         data.page.audio.port[RIGHT_PORT].volume = arg->vol[RIGHT_PORT];
  808. +         data.page.audio.port[2].volume = arg->vol[2];
  809. +         data.page.audio.port[3].volume = arg->vol[3];
  810. +         return cd_set_mode(cd, &data);
  811. +     }
  812. + #else
  813. +     return ENOTTY; 
  814. + #endif
  815. +     case CDIOCSETMONO:
  816. + #ifdef notyet
  817. +     {
  818. +         struct ioc_vol *arg = (struct ioc_vol *)addr;
  819. +         struct cd_mode_data data;
  820. +         if (error = cd_get_mode(cd, &data, AUDIO_PAGE))
  821. +             return error;
  822. +         data.page.audio.port[LEFT_PORT].channels =
  823. +             LEFT_CHANNEL | RIGHT_CHANNEL | 4 | 8;
  824. +         data.page.audio.port[RIGHT_PORT].channels =
  825. +             LEFT_CHANNEL | RIGHT_CHANNEL;
  826. +         data.page.audio.port[2].channels = 0;
  827. +         data.page.audio.port[3].channels = 0;
  828. +         return cd_set_mode(cd, &data);
  829. +     }
  830. + #else
  831. +     return ENOTTY; 
  832. + #endif
  833. +     case CDIOCSETSTEREO:
  834. + #ifdef notyet
  835. +     {
  836. +         struct ioc_vol *arg = (struct ioc_vol *)addr;
  837. +         struct cd_mode_data data;
  838. +         if (error = cd_get_mode(cd, &data, AUDIO_PAGE))
  839. +             return error;
  840. +         data.page.audio.port[LEFT_PORT].channels = LEFT_CHANNEL;
  841. +         data.page.audio.port[RIGHT_PORT].channels = RIGHT_CHANNEL;
  842. +         data.page.audio.port[2].channels = 0;
  843. +         data.page.audio.port[3].channels = 0;
  844. +         return cd_set_mode(cd, &data);
  845. +     }
  846. + #else
  847. +     return ENOTTY; 
  848. + #endif
  849. +     case CDIOCSETMUTE:
  850. + #ifdef notyet
  851. + {
  852. +         struct ioc_vol *arg = (struct ioc_vol *)addr;
  853. +         struct cd_mode_data data;
  854. +         if (error = cd_get_mode(cd, &data, AUDIO_PAGE))
  855. +             return error;
  856. +         data.page.audio.port[LEFT_PORT].channels = 0;
  857. +         data.page.audio.port[RIGHT_PORT].channels = 0;
  858. +         data.page.audio.port[2].channels = 0;
  859. +         data.page.audio.port[3].channels = 0;
  860. +         return cd_set_mode(cd, &data);
  861. +     }
  862. + #else
  863. +     return ENOTTY; 
  864. + #endif
  865. +     case CDIOCSETLEFT:
  866. + #ifdef notyet
  867. + {
  868. +         struct ioc_vol *arg = (struct ioc_vol *)addr;
  869. +         struct cd_mode_data data;
  870. +         if (error = cd_get_mode(cd, &data, AUDIO_PAGE))
  871. +             return error;
  872. +         data.page.audio.port[LEFT_PORT].channels = LEFT_CHANNEL;
  873. +         data.page.audio.port[RIGHT_PORT].channels = LEFT_CHANNEL;
  874. +         data.page.audio.port[2].channels = 0;
  875. +         data.page.audio.port[3].channels = 0;
  876. +         return cd_set_mode(cd, &data);
  877. +     }
  878. + #else
  879. +     return ENOTTY; 
  880. + #endif
  881. +     case CDIOCSETRIGHT:
  882. + #ifdef notyet
  883. + {
  884. +         struct ioc_vol *arg = (struct ioc_vol *)addr;
  885. +         struct cd_mode_data data;
  886. +         if (error = cd_get_mode(cd, &data, AUDIO_PAGE))
  887. +             return error;
  888. +         data.page.audio.port[LEFT_PORT].channels = RIGHT_CHANNEL;
  889. +         data.page.audio.port[RIGHT_PORT].channels = RIGHT_CHANNEL;
  890. +         data.page.audio.port[2].channels = 0;
  891. +         data.page.audio.port[3].channels = 0;
  892. +         return cd_set_mode(cd, &data);
  893. +     }
  894. + #else
  895. +     return ENOTTY; 
  896. + #endif
  897. +     case CDIOCRESUME:
  898. +         return acd_pause(acd, 1);
  899. +     case CDIOCPAUSE:
  900. +         return acd_pause(acd, 0);
  901. +     case CDIOCSTART:
  902. +         return atapi_start_stop(acd->ad_link, SSS_START, 0);
  903. +     case CDIOCSTOP:
  904. +         return atapi_start_stop(acd->ad_link, SSS_STOP, 0);
  905. +     case CDIOCEJECT: /* FALLTHROUGH */
  906. +     case DIOCEJECT:
  907. +         return atapi_start_stop(acd->ad_link, SSS_STOP|SSS_LOEJ, 0);
  908. +     case CDIOCALLOW:
  909. +         return atapi_prevent(acd->ad_link, PR_ALLOW);
  910. +     case CDIOCPREVENT:
  911. +         return atapi_prevent(acd->ad_link, PR_PREVENT);
  912. +     case DIOCLOCK:
  913. +         return atapi_prevent(acd->ad_link,
  914. +             (*(int *)addr) ? PR_PREVENT : PR_ALLOW);
  915. +     case CDIOCRESET:
  916. +         return acd_reset(acd);
  917. +     default:
  918. +         return ENOTTY;
  919. +     }
  920. + 
  921. + #ifdef DIAGNOSTIC
  922. +     panic("cdioctl: impossible");
  923. + #endif
  924. + }
  925. + 
  926. + /*
  927. +  * Load the label information on the named device
  928. +  * Actually fabricate a disklabel
  929. +  *
  930. +  * EVENTUALLY take information about different
  931. +  * data tracks from the TOC and put it in the disklabel
  932. +  */
  933. + void
  934. + acdgetdisklabel(acd)
  935. +     struct acd_softc *acd;
  936. + {
  937. +     struct disklabel *lp = acd->sc_dk.dk_label;
  938. + 
  939. +     bzero(lp, sizeof(struct disklabel));
  940. +     bzero(acd->sc_dk.dk_cpulabel, sizeof(struct cpu_disklabel));
  941. + 
  942. + /*    lp->d_secsize = acd->params.blksize;*/ /* XXX */
  943. +     lp->d_secsize = 2048;
  944. +     lp->d_ntracks = 1;
  945. +     lp->d_nsectors = 100;
  946. +     lp->d_ncylinders = (acd->params.disksize / 100) + 1;
  947. +     lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
  948. + 
  949. +     strncpy(lp->d_typename, "ATAPI CD-ROM", 16);
  950. +     lp->d_type = DTYPE_SCSI; /* XXX */
  951. +     strncpy(lp->d_packname, "fictitious", 16);
  952. +     lp->d_secperunit = acd->params.disksize;
  953. +     lp->d_rpm = 300;
  954. +     lp->d_interleave = 1;
  955. +     lp->d_flags = D_REMOVABLE;
  956. + 
  957. +     lp->d_partitions[0].p_offset = 0;
  958. +     lp->d_partitions[0].p_size =
  959. +         lp->d_secperunit * (lp->d_secsize / DEV_BSIZE);
  960. +     lp->d_partitions[0].p_fstype = FS_ISO9660;
  961. +     lp->d_partitions[RAW_PART].p_offset = 0;
  962. +     lp->d_partitions[RAW_PART].p_size =
  963. +         lp->d_secperunit * (lp->d_secsize / DEV_BSIZE);
  964. +     lp->d_partitions[RAW_PART].p_fstype = FS_ISO9660;
  965. +     lp->d_npartitions = RAW_PART + 1;
  966. + 
  967. +     lp->d_magic = DISKMAGIC;
  968. +     lp->d_magic2 = DISKMAGIC;
  969. +     lp->d_checksum = dkcksum(lp);
  970. + }
  971. + 
  972. + /*
  973. +  * Find out from the device what it's capacity is
  974. +  */
  975. + u_long
  976. + acd_size(cd, flags)
  977. +     struct acd_softc *cd;
  978. +     int flags;
  979. + {
  980. +     struct read_cd_capacity_data rdcap;
  981. +     struct read_cd_capacity cmd;
  982. +     u_long blksize;
  983. +     u_long size=0;
  984. + 
  985. +     /*
  986. +      * make up a atapi command and ask the atapi driver to do
  987. +      * it for you.
  988. +      */
  989. +     bzero(&cmd, sizeof(cmd));
  990. +     cmd.operation_code = ATAPI_READ_CD_CAPACITY;
  991. +     cmd.len = sizeof(rdcap);
  992. + 
  993. +     /*
  994. +      * If the command works, interpret the result as a 4 byte
  995. +      * number of blocks and a blocksize
  996. +      */
  997. +     if (atapi_exec_cmd(cd->ad_link, &cmd , sizeof(cmd),
  998. +         &rdcap, sizeof(rdcap), B_READ, 0) != 0) {
  999. + #ifdef ATAPI_DEBUG
  1000. +         printf("ATAPI_READ_CD_CAPACITY failed\n");
  1001. + #endif
  1002. +         return 0;
  1003. +     }
  1004. + 
  1005. +     blksize = ntohl(rdcap.blksize);
  1006. +     if (blksize < 512)
  1007. +         blksize = 2048;    /* some drives lie ! */
  1008. +     cd->params.blksize = blksize;
  1009. + 
  1010. +     size = ntohl(rdcap.size);
  1011. +     if (size < 100)
  1012. +         size = 400000;    /* ditto */
  1013. +     cd->params.disksize = size;
  1014. + #ifdef ATAPI_DEBUG
  1015. +     printf("acd_size: %ld %ld\n",blksize,size);
  1016. + #endif
  1017. + 
  1018. +     return size;
  1019. + }
  1020. + 
  1021. + #ifdef notyet
  1022. + /*
  1023. +  * Get the requested page into the buffer given
  1024. +  */
  1025. + int
  1026. + cd_get_mode(cd, data, page)
  1027. +     struct acd_softc *cd;
  1028. +     struct cd_mode_data *data;
  1029. +     int page;
  1030. + {
  1031. +     struct scsi_mode_sense scsi_cmd;
  1032. +     int error;
  1033. + 
  1034. +     bzero(&scsi_cmd, sizeof(scsi_cmd));
  1035. +     bzero(data, sizeof(*data));
  1036. +     scsi_cmd.opcode = MODE_SENSE;
  1037. +     scsi_cmd.page = page;
  1038. +     scsi_cmd.length = sizeof(*data) & 0xff;
  1039. +     return scsi_scsi_cmd(cd->ad_link, (struct scsi_generic *)&scsi_cmd,
  1040. +         sizeof(scsi_cmd), (u_char *)data, sizeof(*data), CDRETRIES, 20000,
  1041. +         NULL, SCSI_DATA_IN);
  1042. + }
  1043. + 
  1044. + /*
  1045. +  * Get the requested page into the buffer given
  1046. +  */
  1047. + int
  1048. + cd_set_mode(cd, data)
  1049. +     struct acd_softc *cd;
  1050. +     struct cd_mode_data *data;
  1051. + {
  1052. +     struct scsi_mode_select scsi_cmd;
  1053. + 
  1054. +     bzero(&scsi_cmd, sizeof(scsi_cmd));
  1055. +     scsi_cmd.opcode = MODE_SELECT;
  1056. +     scsi_cmd.byte2 |= SMS_PF;
  1057. +     scsi_cmd.length = sizeof(*data) & 0xff;
  1058. +     data->header.data_length = 0;
  1059. +     return scsi_scsi_cmd(cd->ad_link, (struct scsi_generic *)&scsi_cmd,
  1060. +         sizeof(scsi_cmd), (u_char *)data, sizeof(*data), CDRETRIES, 20000,
  1061. +         NULL, SCSI_DATA_OUT);
  1062. + }
  1063. + 
  1064. + /*
  1065. +  * Get scsi driver to send a "start playing" command
  1066. +  */
  1067. + int
  1068. + cd_play(cd, blkno, nblks)
  1069. +     struct acd_softc *cd;
  1070. +     int blkno, nblks;
  1071. + {
  1072. +     struct scsi_play scsi_cmd;
  1073. + 
  1074. +     bzero(&scsi_cmd, sizeof(scsi_cmd));
  1075. +     scsi_cmd.opcode = PLAY;
  1076. +     scsi_cmd.blk_addr[0] = (blkno >> 24) & 0xff;
  1077. +     scsi_cmd.blk_addr[1] = (blkno >> 16) & 0xff;
  1078. +     scsi_cmd.blk_addr[2] = (blkno >> 8) & 0xff;
  1079. +     scsi_cmd.blk_addr[3] = blkno & 0xff;
  1080. +     scsi_cmd.xfer_len[0] = (nblks >> 8) & 0xff;
  1081. +     scsi_cmd.xfer_len[1] = nblks & 0xff;
  1082. +     return scsi_scsi_cmd(cd->ad_link, (struct scsi_generic *)&scsi_cmd,
  1083. +         sizeof(scsi_cmd), 0, 0, CDRETRIES, 200000, NULL, 0);
  1084. + }
  1085. + 
  1086. + /*
  1087. +  * Get scsi driver to send a "start playing" command
  1088. +  */
  1089. + int
  1090. + cd_play_big(cd, blkno, nblks)
  1091. +     struct acd_softc *cd;
  1092. +     int blkno, nblks;
  1093. + {
  1094. +     struct scsi_play_big scsi_cmd;
  1095. + 
  1096. +     bzero(&scsi_cmd, sizeof(scsi_cmd));
  1097. +     scsi_cmd.opcode = PLAY_BIG;
  1098. +     scsi_cmd.blk_addr[0] = (blkno >> 24) & 0xff;
  1099. +     scsi_cmd.blk_addr[1] = (blkno >> 16) & 0xff;
  1100. +     scsi_cmd.blk_addr[2] = (blkno >> 8) & 0xff;
  1101. +     scsi_cmd.blk_addr[3] = blkno & 0xff;
  1102. +     scsi_cmd.xfer_len[0] = (nblks >> 24) & 0xff;
  1103. +     scsi_cmd.xfer_len[1] = (nblks >> 16) & 0xff;
  1104. +     scsi_cmd.xfer_len[2] = (nblks >> 8) & 0xff;
  1105. +     scsi_cmd.xfer_len[3] = nblks & 0xff;
  1106. +     return scsi_scsi_cmd(cd->ad_link, (struct scsi_generic *)&scsi_cmd,
  1107. +         sizeof(scsi_cmd), 0, 0, CDRETRIES, 20000, NULL, 0);
  1108. + }
  1109. + 
  1110. + /*
  1111. +  * Get scsi driver to send a "start playing" command
  1112. +  */
  1113. + int
  1114. + cd_play_tracks(cd, strack, sindex, etrack, eindex)
  1115. +     struct acd_softc *cd;
  1116. +     int strack, sindex, etrack, eindex;
  1117. + {
  1118. +     struct scsi_play_track scsi_cmd;
  1119. + 
  1120. +     bzero(&scsi_cmd, sizeof(scsi_cmd));
  1121. +     scsi_cmd.opcode = PLAY_TRACK;
  1122. +     scsi_cmd.start_track = strack;
  1123. +     scsi_cmd.start_index = sindex;
  1124. +     scsi_cmd.end_track = etrack;
  1125. +     scsi_cmd.end_index = eindex;
  1126. +     return scsi_scsi_cmd(cd->ad_link, (struct scsi_generic *)&scsi_cmd,
  1127. +         sizeof(scsi_cmd), 0, 0, CDRETRIES, 20000, NULL, 0);
  1128. + }
  1129. + 
  1130. + /*
  1131. +  * Get scsi driver to send a "play msf" command
  1132. +  */
  1133. + int
  1134. + cd_play_msf(cd, startm, starts, startf, endm, ends, endf)
  1135. +     struct acd_softc *cd;
  1136. +     int startm, starts, startf, endm, ends, endf;
  1137. + {
  1138. +     struct scsi_play_msf scsi_cmd;
  1139. + 
  1140. +     bzero(&scsi_cmd, sizeof(scsi_cmd));
  1141. +     scsi_cmd.opcode = PLAY_MSF;
  1142. +     scsi_cmd.start_m = startm;
  1143. +     scsi_cmd.start_s = starts;
  1144. +     scsi_cmd.start_f = startf;
  1145. +     scsi_cmd.end_m = endm;
  1146. +     scsi_cmd.end_s = ends;
  1147. +     scsi_cmd.end_f = endf;
  1148. +     return scsi_scsi_cmd(cd->ad_link, (struct scsi_generic *)&scsi_cmd,
  1149. +         sizeof(scsi_cmd), 0, 0, CDRETRIES, 2000, NULL, 0);
  1150. + }
  1151. + 
  1152. + #endif  /* notyet */
  1153. + 
  1154. + /*
  1155. +  * Get atapi driver to send a "start up" command
  1156. +  */
  1157. + int
  1158. + acd_pause(acd, go)
  1159. +     struct acd_softc *acd;
  1160. +     int go;
  1161. + {
  1162. +     struct pause_resume cmd;
  1163. + 
  1164. +     bzero(&cmd, sizeof(cmd));
  1165. +     cmd.operation_code = ATAPI_PAUSE_RESUME;
  1166. +     cmd.resume = go;
  1167. +     return atapi_exec_cmd(acd->ad_link, &cmd , sizeof(cmd), 0, 0, 0, 0);
  1168. + }
  1169. + 
  1170. + /*
  1171. +  * Get atapi driver to send a "RESET" command
  1172. +  */
  1173. + int
  1174. + acd_reset(acd)
  1175. +     struct acd_softc *acd;
  1176. + {
  1177. + #ifdef notyet    
  1178. +     return atapi_soft_reset(acd->ad_link);
  1179. + #else
  1180. +      return 0;
  1181. + #endif
  1182. + }
  1183. + 
  1184. + #ifdef notyet
  1185. + /*
  1186. +  * Read subchannel
  1187. +  */
  1188. + int
  1189. + cd_read_subchannel(cd, mode, format, track, data, len)
  1190. +     struct acd_softc *cd;
  1191. +     int mode, format, len;
  1192. +     struct cd_sub_channel_info *data;
  1193. + {
  1194. +     struct scsi_read_subchannel scsi_cmd;
  1195. + 
  1196. +     bzero(&scsi_cmd, sizeof(scsi_cmd));
  1197. +     scsi_cmd.opcode = READ_SUBCHANNEL;
  1198. +     if (mode == CD_MSF_FORMAT)
  1199. +         scsi_cmd.byte2 |= CD_MSF;
  1200. +     scsi_cmd.byte3 = SRS_SUBQ;
  1201. +     scsi_cmd.subchan_format = format;
  1202. +     scsi_cmd.track = track;
  1203. +     scsi_cmd.data_len[0] = (len >> 8) & 0xff;
  1204. +     scsi_cmd.data_len[1] = len & 0xff;
  1205. +     return scsi_scsi_cmd(cd->ad_link, (struct scsi_generic *)&scsi_cmd,
  1206. +         sizeof(struct scsi_read_subchannel), (u_char *)data, len,
  1207. +         CDRETRIES, 5000, NULL, SCSI_DATA_IN);
  1208. + }
  1209. + 
  1210. + /*
  1211. +  * Read table of contents
  1212. +  */
  1213. + int
  1214. + cd_read_toc(cd, mode, start, data, len)
  1215. +     struct acd_softc *cd;
  1216. +     int mode, start, len;
  1217. +     struct cd_toc_entry *data;
  1218. + {
  1219. +     struct scsi_read_toc scsi_cmd;
  1220. +     int ntoc;
  1221. + 
  1222. +     bzero(&scsi_cmd, sizeof(scsi_cmd));
  1223. +     /*if (len!=sizeof(struct ioc_toc_header))
  1224. +      * ntoc=((len)-sizeof(struct ioc_toc_header))/sizeof(struct cd_toc_entry);
  1225. +      * else */
  1226. +     ntoc = len;
  1227. +     scsi_cmd.opcode = READ_TOC;
  1228. +     if (mode == CD_MSF_FORMAT)
  1229. +         scsi_cmd.byte2 |= CD_MSF;
  1230. +     scsi_cmd.from_track = start;
  1231. +     scsi_cmd.data_len[0] = (ntoc >> 8) & 0xff;
  1232. +     scsi_cmd.data_len[1] = ntoc & 0xff;
  1233. +     return scsi_scsi_cmd(cd->ad_link, (struct scsi_generic *)&scsi_cmd,
  1234. +         sizeof(struct scsi_read_toc), (u_char *)data, len, CDRETRIES,
  1235. +         5000, NULL, SCSI_DATA_IN);
  1236. + }
  1237. + 
  1238. + #endif /* notyet */
  1239. + 
  1240. + /*
  1241. +  * Get the atapi driver to send a full inquiry to the device and use the
  1242. +  * results to fill out the disk parameter structure.
  1243. +  */
  1244. + int
  1245. + acd_get_parms(acd, flags)
  1246. +     struct acd_softc *acd;
  1247. +     int flags;
  1248. + {
  1249. + 
  1250. +     /*
  1251. +      * give a number of sectors so that sec * trks * cyls
  1252. +      * is <= disk_size
  1253. +      */
  1254. +     if (acd_size(acd, flags) == 0)
  1255. +         return ENXIO;
  1256. + 
  1257. +     return 0;
  1258. + }
  1259. + 
  1260. + int
  1261. + acdsize(dev)
  1262. +     dev_t dev;
  1263. + {
  1264. + 
  1265. +     /* CD-ROMs are read-only. */
  1266. +     return -1;
  1267. + }
  1268. + 
  1269. + void acdminphys(bp)
  1270. + struct buf *bp;
  1271. + {
  1272. +     minphys(bp);
  1273. + }
  1274. + 
  1275. + 
  1276. + int
  1277. + acddump(dev, blkno, va, size)
  1278. +     dev_t dev;
  1279. +     daddr_t blkno;
  1280. +     caddr_t va;
  1281. +     size_t size;
  1282. + {
  1283. + 
  1284. +     /* Not implemented. */
  1285. +     return ENXIO;
  1286. + }
  1287. + 
  1288. + int
  1289. + acddone(acp)
  1290. + struct atapi_command_packet *acp;
  1291. + {
  1292. +     struct at_dev_link *ad_link = acp->ad_link;
  1293. +     struct acd_softc *acd = ad_link->device_softc;
  1294. + 
  1295. +     if (acp->bp != NULL)
  1296. +         disk_unbusy(&acd->sc_dk, (acp->bp->b_bcount - acp->bp->b_resid));
  1297. + 
  1298. +     return (0);     
  1299. + }   
  1300. + 
  1301. diff -c -r -N --exclude exp --exclude compile sys/atapi.orig/atapi.h sys/atapi/atapi.h
  1302. *** sys/atapi.orig/atapi.h    Thu Jan  1 01:00:00 1970
  1303. --- sys/atapi/atapi.h    Thu Jun 13 03:19:49 1996
  1304. ***************
  1305. *** 0 ****
  1306. --- 1,244 ----
  1307. + /*
  1308. +  * Copyright (c) 1996 Manuel Bouyer.  All rights reserved.
  1309. +  *
  1310. +  * Redistribution and use in source and binary forms, with or without
  1311. +  * modification, are permitted provided that the following conditions
  1312. +  * are met:
  1313. +  * 1. Redistributions of source code must retain the above copyright
  1314. +  *    notice, this list of conditions and the following disclaimer.
  1315. +  * 2. Redistributions in binary form must reproduce the above copyright
  1316. +  *    notice, this list of conditions and the following disclaimer in the
  1317. +  *    documentation and/or other materials provided with the distribution.
  1318. +  * 3. All advertising materials mentioning features or use of this software
  1319. +  *    must display the following acknowledgement:
  1320. +  *  This product includes software developed by Manuel Bouyer.
  1321. +  * 4. The name of the author may not be used to endorse or promote products
  1322. +  *    derived from this software without specific prior written permission.
  1323. +  *
  1324. +  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  1325. +  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  1326. +  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  1327. +  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  1328. +  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  1329. +  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  1330. +  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  1331. +  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  1332. +  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  1333. +  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  1334. +  */
  1335. + 
  1336. + /* Definition of atapi commands and associated data structures */
  1337. + /* 
  1338. +    TEST UNIT READY (mandatory)
  1339. +  */
  1340. + 
  1341. + #define ATAPI_TEST_UNIT_READY           0x00
  1342. + 
  1343. + struct test_unit_ready {
  1344. +     u_char  operation_code;
  1345. +     u_char  reserved1[15];
  1346. + };
  1347. + 
  1348. + /* 
  1349. +    START/STOP UNIT (mandatory)
  1350. +    */ 
  1351. +  
  1352. + #define ATAPI_START_STOP_UNIT           0x1b
  1353. +  
  1354. + struct start_stop_unit {
  1355. +     u_char  operation_code;
  1356. +     u_char  immed       :1;
  1357. +     u_char  reserved1   :7;
  1358. +     u_char  reserved2[2]; 
  1359. +     u_char  how;
  1360. + #define SSS_STOP        0x00 
  1361. + #define SSS_START       0x01
  1362. + #define SSS_LOEJ        0x02
  1363. +     u_char  reserved4[11];
  1364. + };
  1365. + 
  1366. + /* 
  1367. +    PREVENT/ALLOW MEDIUM REMOVAL (mandatory)
  1368. +    */ 
  1369. +  
  1370. + #define ATAPI_PREVENT_ALLOW_MEDIUM_REMOVAL  0x1e
  1371. +  
  1372. + struct prevent_allow_medium_removal {
  1373. +     u_char  operation_code;
  1374. +     u_char  reserved1[3];
  1375. +     u_char  prevent     :1;
  1376. + #define PR_PREVENT 0x01
  1377. + #define PR_ALLOW   0x00
  1378. +     u_char  reserved2   :7;
  1379. +     u_char  reserved3[11];
  1380. + };
  1381. + 
  1382. + 
  1383. + /* 
  1384. +    READ CD CAPACITY (mandatory)
  1385. +  */
  1386. +        
  1387. + #define ATAPI_READ_CD_CAPACITY          0x25
  1388. +     
  1389. + struct read_cd_capacity {
  1390. +     u_char  operation_code;
  1391. +     u_char  reserved1[7];
  1392. +     u_char len;
  1393. +     u_char reserved2[7];
  1394. + };
  1395. + 
  1396. + /* 
  1397. +  * Volume size info.
  1398. +  */
  1399. + struct read_cd_capacity_data {
  1400. +     u_long size;         /* Volume size in blocks */
  1401. +     u_long blksize;         /* Block size in bytes */
  1402. + };
  1403. + 
  1404. + 
  1405. + /*
  1406. +    READ (10) (mandatory)
  1407. +  */  
  1408. +     
  1409. + #define ATAPI_READ              0x28  
  1410. + 
  1411. + struct read {    
  1412. +     u_char  operation_code;
  1413. +     u_char  reserved1;  
  1414. +     u_char  lba[4];       
  1415. +     u_char  reserved2;            
  1416. +     u_char  length[2];                    
  1417. +     u_char  reserved3[7];                         
  1418. + }; 
  1419. + 
  1420. + /* 
  1421. +    PAUSE/RESUME (optional) 
  1422. +  */ 
  1423. +  
  1424. + #define ATAPI_PAUSE_RESUME      0x4b
  1425. +  
  1426. + struct pause_resume {
  1427. +     u_char  operation_code;
  1428. +     u_char  reserved1[7];
  1429. +     u_char  resume      :1;
  1430. +     u_char  reserved2   :7;
  1431. +     u_char  reserved3[7];
  1432. + };
  1433. + 
  1434. + 
  1435. + /*
  1436. +    MODE SENSE (mandatory)
  1437. +    */
  1438. + 
  1439. + #define ATAPI_MODE_SENSE        0x5a
  1440. + 
  1441. + struct mode_sense {
  1442. +     u_char  operation_code;
  1443. +     u_char  reserved1;
  1444. +     u_char  page_code   :6;
  1445. +     u_char  page_control    :2;  /* page control */
  1446. +     u_char  reserved2[4];
  1447. +     u_char  length[2];
  1448. +     u_char  reserved3[7];
  1449. + };
  1450. + 
  1451. + struct cappage {
  1452. +     /* Mode data header */
  1453. +     u_short data_length;
  1454. +     u_char  medium_type;
  1455. + #define MDT_UNKNOWN     0x00        
  1456. + #define MDT_DATA_120    0x01
  1457. + #define MDT_AUDIO_120   0x02
  1458. + #define MDT_COMB_120    0x03    
  1459. + #define MDT_PHOTO_120   0x04    
  1460. + #define MDT_DATA_80     0x05
  1461. + #define MDT_AUDIO_80    0x06
  1462. + #define MDT_COMB_80     0x07 
  1463. + #define MDT_PHOTO_80    0x08
  1464. + #define MDT_NO_DISC     0x70
  1465. + #define MDT_DOOR_OPEN   0x71
  1466. + #define MDT_FMT_ERROR   0x72
  1467. +     u_char  reserved1[5];
  1468. + 
  1469. +     /* Capabilities page */
  1470. +     u_char  page_code;
  1471. + #define CAP_PAGE        0x2a
  1472. +     u_char  param_len;
  1473. +     u_char  reserved2[2];
  1474. + 
  1475. +     u_char  audio_play : 1;         /* audio play supported */
  1476. +     u_char  composite : 1;          /* composite audio/video supported */
  1477. +     u_char  dport1 : 1;             /* digital audio on port 1 */
  1478. +     u_char  dport2 : 1;             /* digital audio on port 2 */
  1479. +     u_char  mode2_form1 : 1;        /* mode 2 form 1 (XA) read */
  1480. +     u_char  mode2_form2 : 1;        /* mode 2 form 2 format */
  1481. +     u_char  multisession : 1;       /* multi-session photo-CD */
  1482. +     u_char  : 1;
  1483. +     u_char  cd_da : 1;              /* audio-CD read supported */
  1484. +     u_char  cd_da_stream : 1;       /* CD-DA streaming */
  1485. +     u_char  rw : 1;                 /* combined R-W subchannels */
  1486. +     u_char  rw_corr : 1;            /* R-W subchannel data corrected */
  1487. +     u_char  c2 : 1;                 /* C2 error pointers supported */
  1488. +     u_char  isrc : 1;               /* can return the ISRC info */
  1489. +     u_char  upc : 1;                /* can return the catalog number UPC */
  1490. +     u_char  : 1;
  1491. +     u_char  lock : 1;               /* could be locked */
  1492. +     u_char  locked : 1;             /* current lock state */
  1493. +     u_char  prevent : 1;            /* prevent jumper installed */
  1494. +     u_char  eject : 1;              /* can eject */
  1495. +     u_char  : 1;
  1496. +     u_char  mech : 3;               /* loading mechanism type */
  1497. + #define MECH_CADDY      0
  1498. + #define MECH_TRAY       1
  1499. + #define MECH_POPUP      2
  1500. + #define MECH_CHANGER    4
  1501. + #define MECH_CARTRIDGE  5
  1502. +     u_char  sep_vol : 1;            /* independent volume of channels */
  1503. +     u_char  sep_mute : 1;           /* independent mute of channels */
  1504. +     u_char  : 6;
  1505. + 
  1506. +     u_short max_speed;              /* max raw data rate in bytes/1000 */
  1507. +     u_short max_vol_levels;         /* number of discrete volume levels */
  1508. +     u_short buf_size;               /* internal buffer size in bytes/1024 */
  1509. +     u_short cur_speed;              /* current data rate in bytes/1000  */
  1510. +     /* Digital drive output format description (optional?) */
  1511. +     u_char  reserved3;
  1512. +     u_char  bckf : 1;               /* data valid on failing edge of BCK */
  1513. +     u_char  rch : 1;                /* high LRCK indicates left channel */
  1514. +     u_char  lsbf : 1;               /* set if LSB first */
  1515. +     u_char  dlen: 2;
  1516. + #define DLEN_32         0               /* 32 BCKs */
  1517. + #define DLEN_16         1               /* 16 BCKs */
  1518. + #define DLEN_24         2               /* 24 BCKs */
  1519. + #define DLEN_24_I2S     3               /* 24 BCKs (I2S) */
  1520. +     u_char  : 3;
  1521. +     u_char  reserved4[2];
  1522. + };
  1523. + 
  1524. + /* ATAPI error codes */
  1525. + #define ATAPI_SK_NO_SENSE       0x0
  1526. + #define ATAPI_SK_REC_ERROR      0x1  /* recovered error */
  1527. + #define ATAPI_SK_NOT_READY      0x2
  1528. + #define ATAPI_SK_MEDIUM_ERROR       0x3
  1529. + #define ATAPI_SK_HARDWARE_ERROR     0x4
  1530. + #define ATAPI_SK_ILLEGAL_REQUEST    0x5
  1531. + #define ATAPI_SK_UNIT_ATTENTION     0x6
  1532. + #define ATAPI_SK_DATA_PROTECT       0x7
  1533. +                          /* 0x8 reserved */
  1534. +                          /* 0x9-0xa reserved */
  1535. + #define ATAPI_SK_ABORTED_COMMAND    0xb
  1536. +                         /* 0xc-0xd not referenced */
  1537. + #define ATAPI_SK_MISCOMPARE     0xe
  1538. +                         /* 0xf reserved */
  1539. + 
  1540. + #define ATAPI_MCR           0x08 /* media change requested */
  1541. + #define ATAPI_ABRT          0x04 /* aborted command */
  1542. + #define ATAPI_EOM           0x02 /* end of media */
  1543. + #define ATAPI_ILI           0x01 /* illegal length indication */
  1544. + 
  1545. + 
  1546. + int atapi_exec_cmd __P((struct at_dev_link *, void*, int, void*, int, long, int));
  1547. + int atapi_exec_io __P((struct at_dev_link *, void *, int, struct buf *, int));
  1548. + int atapi_test_unit_ready __P((struct at_dev_link  *, int));
  1549. + int atapi_start_stop __P((struct at_dev_link  *, int, int));
  1550. + int atapi_prevent __P((struct at_dev_link  *, int));
  1551. diff -c -r -N --exclude exp --exclude compile sys/atapi.orig/atapiconf.c sys/atapi/atapiconf.c
  1552. *** sys/atapi.orig/atapiconf.c    Thu Jan  1 01:00:00 1970
  1553. --- sys/atapi/atapiconf.c    Thu Jun 13 03:19:49 1996
  1554. ***************
  1555. *** 0 ****
  1556. --- 1,588 ----
  1557. + /*
  1558. +  * Copyright (c) 1996 Manuel Bouyer.  All rights reserved.
  1559. +  *
  1560. +  * Redistribution and use in source and binary forms, with or without
  1561. +  * modification, are permitted provided that the following conditions
  1562. +  * are met:
  1563. +  * 1. Redistributions of source code must retain the above copyright
  1564. +  *    notice, this list of conditions and the following disclaimer.
  1565. +  * 2. Redistributions in binary form must reproduce the above copyright
  1566. +  *    notice, this list of conditions and the following disclaimer in the
  1567. +  *    documentation and/or other materials provided with the distribution.
  1568. +  * 3. All advertising materials mentioning features or use of this software
  1569. +  *    must display the following acknowledgement:
  1570. +  *  This product includes software developed by Manuel Bouyer.
  1571. +  * 4. The name of the author may not be used to endorse or promote products
  1572. +  *    derived from this software without specific prior written permission.
  1573. +  *
  1574. +  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  1575. +  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  1576. +  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  1577. +  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  1578. +  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  1579. +  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  1580. +  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  1581. +  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  1582. +  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  1583. +  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  1584. +  */
  1585. + 
  1586. + #include <sys/types.h>
  1587. + #include <sys/param.h>
  1588. + #include <sys/systm.h>
  1589. + #include <sys/malloc.h>
  1590. + #include <sys/device.h>
  1591. + #include <sys/buf.h>
  1592. + #include <sys/proc.h>  
  1593. + 
  1594. + #include <atapi/atapilink.h>
  1595. + #include <atapi/atapi.h>
  1596. + #define SILENT_PRINTF(flags,string) if (!(flags & A_SILENT)) printf string
  1597. + 
  1598. + struct atapibus_softc {
  1599. +     struct device sc_dev;
  1600. +     struct bus_link *b_link;
  1601. +     struct atapi_devices *ad_link[2];
  1602. + };
  1603. + 
  1604. + LIST_HEAD(pkt_free_list, atapi_command_packet) pkt_free_list;
  1605. + 
  1606. + void bswap __P((char*, int));
  1607. + void btrim __P((char*, int));
  1608. + 
  1609. + int atapi_error __P((struct atapi_command_packet*));
  1610. + void atapi_sense __P((struct atapi_command_packet*, u_char, u_char));
  1611. + void at_print_addr __P((struct at_dev_link*, u_char));
  1612. + 
  1613. + int atapibusmatch __P((struct device *, void *, void *));
  1614. + void atapibusattach __P((struct device *, struct device *, void *));
  1615. + 
  1616. + struct cfattach atapibus_ca = {
  1617. +     sizeof(struct atapibus_softc), atapibusmatch, atapibusattach,
  1618. + };
  1619. + 
  1620. + struct cfdriver atapibus_cd = {
  1621. +     NULL, "atapibus", DV_DULL
  1622. + };
  1623. + 
  1624. + 
  1625. + int
  1626. + atapibusmatch(parent, match, aux)
  1627. +         struct device *parent;
  1628. +         void *match, *aux;
  1629. + {
  1630. + /*    struct cfdata *cf = match;*/
  1631. +     struct bus_link *ab_link = aux;
  1632. + 
  1633. +     if (ab_link == NULL ) return 0;
  1634. +     if (ab_link-> type != BUS) return 0;
  1635. +     return 1;
  1636. + }
  1637. + 
  1638. + int
  1639. + atapiprint(aux, bus)
  1640. +     void *aux;
  1641. +     char *bus;
  1642. + {
  1643. +     struct at_dev_link *ad_link = aux;
  1644. +  
  1645. +      if (!bus)
  1646. +          printf(" drive %d: ", ad_link->drive); 
  1647. +      return QUIET; 
  1648. + }
  1649. + 
  1650. + 
  1651. + void atapibusattach(parent, self, aux)
  1652. +         struct device *parent, *self;
  1653. +         void *aux;
  1654. + {
  1655. +     struct atapibus_softc *ab = (struct atapibus_softc *)self;
  1656. +     struct bus_link *ab_link_proto = aux;
  1657. +     int drive;
  1658. +     struct atapi_identify ids;
  1659. +     struct atapi_identify *id = &ids;
  1660. +     struct at_dev_link *ad_link;
  1661. + 
  1662. +     ab_link_proto->atapibus_softc = (caddr_t)ab;
  1663. +     ab->b_link = ab_link_proto;
  1664. +     printf("\n");
  1665. +     for (drive = 0; drive < 2 ; drive++) {
  1666. +         if (wdc_atapi_get_params(ab_link_proto, drive, id)) {
  1667. +             /*
  1668. +              * Shuffle string byte order.
  1669. +              * Mitsumi and NEC drives don't need this.
  1670. +              */
  1671. +             if (! ((id->model[0] == 'N' && id->model[1] == 'E') ||
  1672. +                 (id->model[0] == 'F' && id->model[1] == 'X')))
  1673. +                 bswap(id->model, sizeof(id->model));
  1674. +             bswap (id->serial_number, sizeof(id->serial_number));
  1675. +             bswap (id->firmware_revision, sizeof(id->firmware_revision));
  1676. +             /* Clean up the model name, serial and revision numbers. */
  1677. +             btrim (id->model, sizeof(id->model));
  1678. +             btrim (id->serial_number, sizeof(id->serial_number));
  1679. +             btrim (id->firmware_revision, sizeof(id->firmware_revision));
  1680. +             printf("atapibus%d drive%d: <%s, %s, %s> ",
  1681. +                 ab->sc_dev.dv_unit, drive, id->model, id->serial_number, id->firmware_revision);
  1682. +             switch (id->config.device_type) {
  1683. +             case ATAPI_DEVICE_TYPE_DAD: printf("direct, ");
  1684. +                                        break;
  1685. +             case ATAPI_DEVICE_TYPE_CD: printf("cdrom, ");
  1686. +                                        break;
  1687. +             case ATAPI_DEVICE_TYPE_OMD: printf(" optical, ");
  1688. +                                        break;
  1689. +             default: printf(" unknown type %d, ",id->config.device_type);
  1690. +             }
  1691. +             printf("%s.\n", id->config.removable?"removable":"fixed");
  1692. + #ifdef ATAPI_DEBUG_PROBE
  1693. +             printf("cmdsz %d drqtype %d\n",id->config.packet_size, id->config.drq_type);
  1694. + #endif
  1695. +             
  1696. +             ad_link = malloc(sizeof(*ad_link), M_DEVBUF, M_NOWAIT);
  1697. +             if (ad_link == NULL) {
  1698. +                 printf("Warning: cannot allocate memory for device\n");
  1699. +                 continue;
  1700. +             }
  1701. +             ad_link->drive = drive;
  1702. +             if (id->config.packet_size) ad_link->flags |= ACAP_LEN;
  1703. +             ad_link->flags |= id->config.drq_type << 8;
  1704. +             bcopy(id, &ad_link->id, sizeof(*id));
  1705. +             ad_link->bus=ab_link_proto;
  1706. +             if (config_found(self,ad_link,atapiprint) == NULL) {
  1707. +                 printf("atapibus:config not found\n");
  1708. +                 free(ad_link,M_DEVBUF);
  1709. +             }
  1710. +         }
  1711. +     }
  1712. + }
  1713. + 
  1714. + void
  1715. + bswap (buf, len)
  1716. + char *buf;
  1717. + int len;
  1718. + {       
  1719. +     u_short *p = (u_short*) (buf + len);
  1720. +     while (--p >= (u_short*) buf)
  1721. +             *p = ntohs (*p);
  1722. + }   
  1723. + 
  1724. + void
  1725. + btrim (buf, len)
  1726. + char *buf;
  1727. + int len;
  1728. + {
  1729. +     char *p; 
  1730. +      
  1731. +      /* Remove the trailing spaces. */
  1732. +      for (p=buf; p<buf+len; ++p)
  1733. +          if (! *p)
  1734. +              *p = ' ';
  1735. +          for (p=buf+len-1; p>=buf && *p==' '; --p)
  1736. +              *p = 0;
  1737. + }
  1738. + 
  1739. + int atapi_exec_cmd(ad_link, cmd, cmd_size, databuf, datalen, rw, flags)
  1740. + struct at_dev_link *ad_link;
  1741. + void *cmd;
  1742. + int cmd_size;
  1743. + void *databuf;
  1744. + int datalen;
  1745. + long rw;
  1746. + int flags;
  1747. + {
  1748. +     struct atapi_command_packet *pkt;
  1749. +     struct bus_link *b_link = ad_link->bus;
  1750. +     int status, s;
  1751. + 
  1752. +     pkt = atapi_get_pkt(ad_link, flags);
  1753. +     if (!pkt) return -1;
  1754. +     bcopy(cmd, &pkt->cmd_store, cmd_size);
  1755. +     pkt->command = &pkt->cmd_store;
  1756. +     pkt->command_size = (ad_link->flags & ACAP_LEN)?16:12;
  1757. +     pkt->databuf = databuf;
  1758. +     pkt->data_size = datalen;
  1759. +     pkt->flags = rw|(flags & 0xff)| (ad_link->flags & 0x0300);
  1760. +     pkt->drive = ad_link->drive;
  1761. +     wdc_atapi_send_command_packet(b_link, pkt);
  1762. +     if ((flags & (A_POLLED|A_NOSLEEP)) == 0 ) {
  1763. + #ifdef ATAPI_DEBUG_CMD
  1764. +         printf("atapi_exec_cmd: sleeping\n");
  1765. + #endif
  1766. +         s=splbio();
  1767. +         while ((pkt->status & ITSDONE) == 0)
  1768. +             tsleep(pkt,PRIBIO+1,"atapicmd",0);
  1769. +         splx(s);
  1770. + #ifdef ATAPI_DEBUG_CMD
  1771. +         printf("atapi_exec_cmd: done sleeping\n");
  1772. + #endif
  1773. +         status = pkt->status & STATUS_MASK;
  1774. +         atapi_free_pkt(pkt);
  1775. +     } else {
  1776. +         if ((flags & A_POLLED) != 0) {
  1777. +             if ((pkt->status & ERROR) && (pkt->error)) {
  1778. +                 atapi_error(pkt);
  1779. +                 SILENT_PRINTF(flags,("\n"));
  1780. +             }
  1781. +         }
  1782. +         status = pkt->status & STATUS_MASK;
  1783. +         if ((flags & A_POLLED) != 0)
  1784. +             atapi_free_pkt(pkt);
  1785. + 
  1786. +     }
  1787. +     return status;
  1788. + }
  1789. + 
  1790. + int atapi_exec_io(ad_link, cmd, cmd_size, bp, flags)
  1791. + struct at_dev_link *ad_link;
  1792. + void *cmd;
  1793. + int cmd_size;
  1794. + struct buf *bp;
  1795. + int flags;
  1796. + {
  1797. +     struct atapi_command_packet *pkt;
  1798. +     struct bus_link *b_link = ad_link->bus;
  1799. + 
  1800. +     pkt = atapi_get_pkt(ad_link, flags);
  1801. +     if (pkt == NULL) {
  1802. +         printf("atapi_exec_io: no pkt\n");
  1803. +         return ERROR;
  1804. +     }
  1805. +     bcopy(cmd, &pkt->cmd_store, cmd_size);
  1806. +     pkt->command = &pkt->cmd_store;
  1807. +     pkt->command_size = (ad_link->flags & ACAP_LEN)?16:12;
  1808. +     pkt->bp = bp;
  1809. +     pkt->databuf = bp->b_data;
  1810. +     pkt->data_size = bp->b_bcount;
  1811. +     pkt->flags = bp->b_flags & ((B_READ|B_WRITE)|(flags & 0xff)|
  1812. +             (ad_link->flags & 0x0300));
  1813. +     pkt->drive = ad_link->drive;
  1814. +     wdc_atapi_send_command_packet(b_link, pkt);
  1815. +     return (pkt->status & STATUS_MASK);
  1816. + }
  1817. + 
  1818. + void atapi_done(acp)
  1819. + struct atapi_command_packet *acp;
  1820. + {
  1821. +     struct at_dev_link *ad_link=acp->ad_link;
  1822. +     struct buf *bp = acp->bp;
  1823. +     int error = 0;
  1824. + 
  1825. + #ifdef ATAPI_DEBUG_CMD
  1826. +     printf("atapi_done\n");
  1827. + #endif
  1828. + 
  1829. +     if ((acp->status & ERROR) && (acp->error)) {
  1830. +         atapi_error(acp);
  1831. +         if (acp->status & RETRY) {
  1832. +             if (acp->retries <ATAPI_NRETRIES) {
  1833. +                 acp->retries++;
  1834. +                 acp->status = 0;
  1835. +                 acp->error = 0;
  1836. +                 SILENT_PRINTF(acp->flags & 0xff,(", retry #%d\n",acp->retries));
  1837. +                 wdc_atapi_send_command_packet(ad_link->bus, acp);
  1838. +                 return;
  1839. +             } else acp->status = ERROR;
  1840. +         }
  1841. +         SILENT_PRINTF(acp->flags & 0xff,("\n"));
  1842. +     }
  1843. +     acp->status |= ITSDONE;
  1844. + 
  1845. +     if (ad_link->done) {
  1846. + #ifdef ATAPI_DEBUG_CMD
  1847. +         printf("calling private done\n");
  1848. + #endif
  1849. +         error = (*ad_link->done) (acp);
  1850. +         if (error == EJUSTRETURN) return;
  1851. +     }
  1852. +     if (acp->bp == NULL) {
  1853. + #ifdef ATAPI_DEBUG_CMD
  1854. +         printf("atapidone: wakeup acp\n");
  1855. + #endif
  1856. +         wakeup(acp);
  1857. +         return;
  1858. +     }
  1859. + #ifdef ATAPI_DEBUG_CMD
  1860. +     printf("atapi_done: status %d\n", acp->status);
  1861. + #endif
  1862. +     switch (acp->status&0x0f) {
  1863. +     case MEDIA_CHANGE:
  1864. +         if (ad_link->flags & ADEV_REMOVABLE) {
  1865. +             ad_link->flags &= ~ADEV_MEDIA_LOADED;
  1866. +         }
  1867. +         error=EIO;
  1868. +         break;
  1869. +     case NO_ERROR:
  1870. +         error=0;
  1871. +         break;
  1872. +     case ERROR:
  1873. +     case END_OF_MEDIA:
  1874. +     default:
  1875. +         error=EIO;
  1876. +         break;
  1877. +     }
  1878. +     switch (acp->status&0xf0) {
  1879. +     case NOT_READY:
  1880. +     case UNIT_ATTENTION:
  1881. +         if (ad_link->flags & ADEV_REMOVABLE) {  
  1882. +             ad_link->flags &= ~ADEV_MEDIA_LOADED;
  1883. +         }   
  1884. +         error=EIO;
  1885. +         break;
  1886. +     default:
  1887. +     }
  1888. + 
  1889. +     if (error) {
  1890. +         bp->b_error = error;;
  1891. +         bp->b_flags |= B_ERROR;
  1892. +         bp->b_resid = bp->b_bcount;
  1893. +     } else {
  1894. +         bp->b_error = 0;
  1895. +         bp->b_resid = acp->data_size;
  1896. +     }
  1897. +     biodone(bp);
  1898. +     atapi_free_pkt(acp);
  1899. + }
  1900. + 
  1901. + struct atapi_command_packet *
  1902. + atapi_get_pkt(ad_link, flags)
  1903. + struct at_dev_link *ad_link;
  1904. + int flags;
  1905. + {
  1906. +     struct atapi_command_packet *pkt;
  1907. +     int s;
  1908. + 
  1909. +     s = splbio();
  1910. +     while (ad_link->openings <= 0) {
  1911. +         if (flags & A_NOSLEEP) {
  1912. +             splx(s);
  1913. +             return 0;
  1914. +         }
  1915. + #ifdef ATAPI_DEBUG_CMD
  1916. +         printf("atapi_get_pkt: sleeping\n");
  1917. + #endif
  1918. +         ad_link->flags |= ADEV_WAITING;
  1919. +         (void) tsleep(ad_link, PRIBIO, "getpkt", 0);
  1920. +     }
  1921. +     ad_link->openings--;
  1922. +     if ((pkt = pkt_free_list.lh_first) != 0) {
  1923. +         LIST_REMOVE(pkt, free_list);
  1924. +         splx(s);
  1925. +     } else {
  1926. +         splx(s);
  1927. +         pkt = malloc(sizeof(struct atapi_command_packet), M_DEVBUF,
  1928. +             ((flags & A_NOSLEEP) != 0 ? M_NOWAIT : M_WAITOK));
  1929. +         if (!pkt) {
  1930. +             printf("atapi_get_pkt: cannot allocate pkt\n");
  1931. +             ad_link->openings++;
  1932. +             return 0;
  1933. +         }
  1934. +     }
  1935. +     bzero(pkt, sizeof(struct atapi_command_packet));
  1936. +     pkt->ad_link = ad_link;
  1937. +     return pkt;
  1938. + }
  1939. + 
  1940. + void
  1941. + atapi_free_pkt(pkt)
  1942. + struct atapi_command_packet *pkt;
  1943. + {
  1944. +     struct at_dev_link *ad_link = pkt->ad_link;
  1945. +     int s;
  1946. + 
  1947. +     s = splbio();
  1948. +     LIST_INSERT_HEAD(&pkt_free_list, pkt, free_list);
  1949. + 
  1950. +     ad_link->openings++;
  1951. +     if ((ad_link->flags & ADEV_WAITING) != 0) {
  1952. +         ad_link->flags &= ~ADEV_WAITING;
  1953. +         wakeup(ad_link);
  1954. +     } else {
  1955. +         if (ad_link->start) {
  1956. + #ifdef ATAPI_DEBUG_CMD
  1957. +             printf("atapi_free_pkt: calling private start\n");
  1958. + #endif
  1959. +             (*(ad_link->start)) ((void*)ad_link->device_softc);
  1960. +         }
  1961. +     }
  1962. +     splx(s);
  1963. + }
  1964. + 
  1965. + int
  1966. + atapi_test_unit_ready(ad_link, flags)
  1967. + struct at_dev_link  *ad_link;
  1968. + int flags;
  1969. + {    
  1970. +     int ret;
  1971. +     struct test_unit_ready cmd;
  1972. + #ifdef ATAPI_DEBUG_FCTN
  1973. +     printf("atapi_test_unit_ready: ");
  1974. + #endif
  1975. +     bzero(&cmd, sizeof(cmd));
  1976. +     cmd.operation_code = ATAPI_TEST_UNIT_READY;
  1977. +     ret = atapi_exec_cmd(ad_link, &cmd, sizeof(cmd), 0,0,0,flags);
  1978. + #ifdef ATAPI_DEBUG_FCTN
  1979. +     printf("atapi_test_unit_ready: ret %d\n", ret);
  1980. + #endif
  1981. +     return ret;
  1982. + }
  1983. + 
  1984. + int
  1985. + atapi_start_stop(ad_link, how, flags)
  1986. + struct at_dev_link  *ad_link;
  1987. + int how;
  1988. + int flags;
  1989. + {
  1990. +     struct start_stop_unit cmd;
  1991. +     int ret;
  1992. +         
  1993. + #ifdef ATAPI_DEBUG_FCTN
  1994. +     printf("atapi_start_stop: ");
  1995. + #endif
  1996. +     bzero(&cmd, sizeof(cmd));
  1997. +     cmd.operation_code = ATAPI_START_STOP_UNIT;
  1998. +     cmd.how = how;
  1999. +     ret = atapi_exec_cmd(ad_link, &cmd, sizeof(cmd), 0,0,0,flags);
  2000. + #ifdef ATAPI_DEBUG_FCTN
  2001. +     printf("ret %d\n", ret);
  2002. + #endif
  2003. +     return ret;
  2004. + }
  2005. + 
  2006. + int
  2007. + atapi_prevent(ad_link, how)
  2008. + struct at_dev_link  *ad_link;
  2009. + int how;
  2010. + {
  2011. +     struct prevent_allow_medium_removal cmd;
  2012. +     int ret;
  2013. + 
  2014. + #ifdef ATAPI_DEBUG_FCTN
  2015. +     printf("atapi_prevent: ");
  2016. + #endif
  2017. +     bzero(&cmd, sizeof(cmd));
  2018. +     cmd.operation_code = ATAPI_PREVENT_ALLOW_MEDIUM_REMOVAL;
  2019. +     cmd.prevent = how;
  2020. +     ret = atapi_exec_cmd(ad_link, &cmd, sizeof(cmd), 0,0,0,0);
  2021. + #ifdef ATAPI_DEBUG_FCTN
  2022. +     printf("ret %d\n", ret);
  2023. + #endif
  2024. +     return ret;
  2025. + }
  2026. + 
  2027. + int 
  2028. + atapi_error(acp)
  2029. + struct atapi_command_packet* acp;
  2030. + {
  2031. +     int flags, error, ret = -1;
  2032. +     struct at_dev_link *ad_link = acp->ad_link;
  2033. +     flags = acp->flags & 0xff;
  2034. +     error = acp->error;
  2035. +     at_print_addr(ad_link, acp->flags & 0xff);
  2036. +     if (error & ATAPI_MCR) {
  2037. +         SILENT_PRINTF(flags,("media change requested"));
  2038. +         acp->status = MEDIA_CHANGE;
  2039. +     }
  2040. +     if (error & ATAPI_ABRT) {      
  2041. +         SILENT_PRINTF(flags,("command aborted"));
  2042. +         acp->status = ERROR; 
  2043. +     }
  2044. +     if (error & ATAPI_EOM) {
  2045. +         SILENT_PRINTF(flags,("end of media"));
  2046. +         acp->status = END_OF_MEDIA;
  2047. +     }
  2048. +     if (error & ATAPI_ILI) {
  2049. +         SILENT_PRINTF(flags,("illegal length indication"));
  2050. +         acp->status = ERROR;
  2051. +     }
  2052. +     if ((error & 0x0f) == 0) {
  2053. +         ret=0;
  2054. +     }
  2055. +     atapi_sense (acp, error >> 4, flags);
  2056. +     if (!(flags & A_SILENT) && (acp->status != NO_ERROR)) {
  2057. +         int i;
  2058. +         printf(", command:");
  2059. +         for (i=0; i< acp->command_size; i++)
  2060. +             printf(" %2x", ((u_char*)acp->command)[i]);
  2061. +     }
  2062. +     return ret;
  2063. + }
  2064. + 
  2065. + void
  2066. + atapi_sense(acp, sense_key, flags)
  2067. + struct atapi_command_packet *acp;
  2068. + u_char sense_key;
  2069. + u_char flags;
  2070. + {
  2071. +     struct at_dev_link *ad_link = acp->ad_link;
  2072. + 
  2073. +     switch (sense_key)
  2074. +     {
  2075. +     case ATAPI_SK_NO_SENSE:
  2076. +     break;
  2077. + 
  2078. +     case ATAPI_SK_REC_ERROR:
  2079. +     SILENT_PRINTF(flags,("recovered error"));
  2080. +     acp->status = 0;
  2081. +     break;
  2082. + 
  2083. +     case ATAPI_SK_NOT_READY:
  2084. +     SILENT_PRINTF(flags,("not ready"));
  2085. +     acp->status = NOT_READY;
  2086. +     break;
  2087. + 
  2088. +     case ATAPI_SK_MEDIUM_ERROR:
  2089. +     SILENT_PRINTF(flags,("medium error"));
  2090. +     acp->status = ERROR;
  2091. +     break;
  2092. + 
  2093. +     case ATAPI_SK_HARDWARE_ERROR:
  2094. +     SILENT_PRINTF(flags,("hardware error"));
  2095. +     acp->status = ERROR;
  2096. +     break;
  2097. + 
  2098. +     case ATAPI_SK_ILLEGAL_REQUEST:
  2099. +     SILENT_PRINTF(flags,("illegal request"));
  2100. +     acp->status = ERROR;
  2101. +     break;
  2102. + 
  2103. +     case ATAPI_SK_UNIT_ATTENTION:
  2104. +     SILENT_PRINTF(flags,("unit attention"));
  2105. +     acp->status = UNIT_ATTENTION;
  2106. +     if (ad_link->flags & ADEV_REMOVABLE) {  
  2107. +         ad_link->flags &= ~ADEV_MEDIA_LOADED;
  2108. +     }   
  2109. +     break;
  2110. + 
  2111. +     case ATAPI_SK_DATA_PROTECT:
  2112. +     SILENT_PRINTF(flags,("data protect"));
  2113. +     acp->status = ERROR;
  2114. +     break;
  2115. + 
  2116. +     case ATAPI_SK_ABORTED_COMMAND:
  2117. +     SILENT_PRINTF(flags,("aborted command"));
  2118. +     acp->status = RETRY;
  2119. +     break;
  2120. + 
  2121. +     case ATAPI_SK_MISCOMPARE:
  2122. +     SILENT_PRINTF(flags,("miscompare"));
  2123. +     acp->status = ERROR;
  2124. +     break;
  2125. + 
  2126. +     default:
  2127. +     SILENT_PRINTF(flags,("unexpected sense key %02x", sense_key));
  2128. +     acp->status = ERROR;
  2129. +     break;
  2130. +     }
  2131. + }
  2132. + 
  2133. + void
  2134. + at_print_addr(ad_link, flags)
  2135. +     struct at_dev_link *ad_link; 
  2136. +     u_char flags;
  2137. + {
  2138. +     if (flags & A_SILENT) return;
  2139. +     printf("%s(%s:%d): ",
  2140. +         ad_link->device_softc ?
  2141. +         ((struct device *)ad_link->device_softc)->dv_xname : "probe",
  2142. +         ((struct device *)ad_link->bus->wdc_softc)->dv_xname,
  2143. +         ad_link->drive);
  2144. + }       
  2145. diff -c -r -N --exclude exp --exclude compile sys/atapi.orig/atapilink.h sys/atapi/atapilink.h
  2146. *** sys/atapi.orig/atapilink.h    Thu Jan  1 01:00:00 1970
  2147. --- sys/atapi/atapilink.h    Thu Jun 13 03:19:49 1996
  2148. ***************
  2149. *** 0 ****
  2150. --- 1,186 ----
  2151. + /*
  2152. +  * Copyright (c) 1996 Manuel Bouyer.  All rights reserved.
  2153. +  *
  2154. +  * Redistribution and use in source and binary forms, with or without
  2155. +  * modification, are permitted provided that the following conditions
  2156. +  * are met:
  2157. +  * 1. Redistributions of source code must retain the above copyright
  2158. +  *    notice, this list of conditions and the following disclaimer.
  2159. +  * 2. Redistributions in binary form must reproduce the above copyright
  2160. +  *    notice, this list of conditions and the following disclaimer in the
  2161. +  *    documentation and/or other materials provided with the distribution.
  2162. +  * 3. All advertising materials mentioning features or use of this software
  2163. +  *    must display the following acknowledgement:
  2164. +  *  This product includes software developed by Manuel Bouyer.
  2165. +  * 4. The name of the author may not be used to endorse or promote products
  2166. +  *    derived from this software without specific prior written permission.
  2167. +  *
  2168. +  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  2169. +  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  2170. +  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  2171. +  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  2172. +  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  2173. +  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  2174. +  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  2175. +  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  2176. +  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  2177. +  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  2178. +  */
  2179. + 
  2180. + #undef ATAPI_DEBUG
  2181. + #undef ATAPI_DEBUG_PROBE
  2182. + 
  2183. + struct bus_link {
  2184. +     u_int8_t type;  
  2185. + #define DRIVE 0
  2186. + #define BUS 1
  2187. +     caddr_t wdc_softc;
  2188. +     caddr_t atapibus_softc;
  2189. +     struct wdc_link *ctlr_link;
  2190. +     u_int8_t ctrl;
  2191. + };
  2192. + 
  2193. + struct atapi_identify {
  2194. +     struct config_s {
  2195. +     u_int8_t  packet_size :2;
  2196. + #define ATAPI_PACKET_SIZE_12        0x0
  2197. + #define ATAPI_PACKET_SIZE_16        0x1
  2198. +                          /* 1xb reserved */
  2199. +     u_int8_t  reserved1   :3;
  2200. +     u_int8_t  drq_type    :2;
  2201. + #define ATAPI_MICROPROCESSOR_DRQ    0x0
  2202. + #define ATAPI_INTERRUPT_DRQ     0x1
  2203. + #define ATAPI_ACCELERATED_DRQ       0x2
  2204. +                          /* 0x3 reserved */
  2205. +     u_int8_t  removable   :1;
  2206. +     u_int8_t  device_type :5;
  2207. + #define ATAPI_DEVICE_TYPE_DAD       0x0  /* direct access device, eg magnetic di
  2208. + sk */
  2209. +                          /* 0x1-0x4 reserved */
  2210. + #define ATAPI_DEVICE_TYPE_CD        0x5
  2211. +                          /* 0x6 reserved */
  2212. + #define ATAPI_DEVICE_TYPE_OMD       0x7  /* optical memory device */
  2213. +                          /* 0x8-0x1e reserved */
  2214. + #define ATAPI_DEVICE_TYPE_UNKNOWN   0x1f
  2215. +     u_int8_t  reserved2   :1;
  2216. +     u_int8_t  protocol_type   :2;
  2217. +                          /* 0x0, 0x1 are ATA */
  2218. + #define ATAPI_GC_PROTO_TYPE_ATAPI   0x2
  2219. + #define ATAPI_GC_PROTO_TYPE_RESERVED    0x3
  2220. +     } config;                /* general configuration */
  2221. +     u_int16_t cylinders;
  2222. +     u_int16_t reserved1;
  2223. +     u_int16_t heads;
  2224. +     u_int16_t unf_bytes_per_track;
  2225. +     u_int16_t unf_bytes_per_sector;
  2226. +     u_int16_t sectors_per_track;
  2227. +     u_int16_t reserved2[3];
  2228. +     char    serial_number[20];
  2229. +     u_int16_t buffer_type;
  2230. +     u_int16_t buffer_size;
  2231. +     u_int16_t ECC_bytes_available;
  2232. +     char    firmware_revision[8];
  2233. +     char    model[40];
  2234. +     u_int16_t sector_count;
  2235. +     u_int16_t double_word;             /* ==0 for CD-ROMs */
  2236. +     struct capabilities_s {
  2237. +       u_int8_t    vendor;
  2238. +       u_int8_t    dma     :1;      /* DMA supported */
  2239. +       u_int8_t    lba     :1;      /* LBA supported */
  2240. +       u_int8_t    iordy_disable   :1;      /* IORDY can be disabled */
  2241. +       u_int8_t    iordy       :1;      /* IORDY supported */
  2242. +       u_int8_t    reserved1   :4;
  2243. +     } capabilities;
  2244. +     u_int16_t reserved3;
  2245. +     u_int16_t PIO_cycle_timing;
  2246. +     u_int16_t DMA_cycle_timing;
  2247. +     u_int16_t validity;            /* of words 54-58, 64-70 in this table */
  2248. + 
  2249. + #define ATAPI_VALID_FIRST       0x0  /* == 1 => words 54-58 are valid */
  2250. + #define ATAPI_VALID_SECOND      0x1  /* == 1 => words 64-70 are valid */
  2251. + 
  2252. +     u_int16_t current_chs[3];          /* cylinder/head/sector */
  2253. +     u_int16_t current_capacity[2];
  2254. +     u_int16_t reserved4;
  2255. +     u_int16_t user_addressable_sectors[2];
  2256. +     u_int16_t singleword_DMA_mode;
  2257. + 
  2258. + #define ATAPI_SW_DMA_MODE_AVAIL     0x00ff /* bit 0 set => Mode 0 is supported */
  2259. + #define ATAPI_SW_DMA_MODE_ACTIVE    0xff00 /* which mode is active */
  2260. + 
  2261. +     u_int16_t multiword_DMA_mode;
  2262. + 
  2263. + #define ATAPI_MW_DMA_MODE_AVAIL     0x00ff /* bit 0 set => Mode 0 is supported */
  2264. + #define ATAPI_MW_DMA_MODE_ACTIVE    0xff00 /* which mode is active */
  2265. + 
  2266. +     u_int16_t enhanced_PIO_mode;
  2267. + 
  2268. + #define ATAPI_ENHANCED_PIO_AVAIL    0x0001 /* bit 0 set => PIO Mode 3 is support
  2269. + ed */
  2270. + 
  2271. +     u_int16_t blind_PIO_minimum_cycles;
  2272. +     u_int16_t mw_dma_tct;          /* multi-word DMA transfer cycle time */
  2273. +     u_int16_t min_PIO_tct_no_flow_control;
  2274. +     u_int16_t min_PIO_tct_with_flow_control;
  2275. +     u_int16_t reserved5[2];
  2276. +     u_int16_t reserved6[57];
  2277. +     u_int16_t vendor[32];          /* vendor unique */
  2278. +     u_int16_t reserved7[96];
  2279. + };
  2280. + 
  2281. + struct at_dev_link {
  2282. +     void *device_softc;
  2283. +     u_int8_t drive;
  2284. +     u_int8_t openings;
  2285. +     struct atapi_identify id;  
  2286. +     struct bus_link *bus;
  2287. +     u_int16_t flags;
  2288. + #define ADEV_REMOVABLE      0x001    /* media is removable */
  2289. + #define ADEV_MEDIA_LOADED   0x002    /* device figures are still valid */  
  2290. + #define ADEV_WAITING        0x004    /* a process is waiting for this */
  2291. + #define ADEV_OPEN           0x008    /* at least 1 open session */
  2292. + #define ACAP_DRQ_MPROC        0x000   /* microprocessor DRQ */
  2293. + #define ACAP_DRQ_INTR        0x100    /* interrupt DRQ */
  2294. + #define ACAP_DRQ_ACCEL        0x200    /* accelerated DRQ */
  2295. + #define ACAP_LEN             0x400   /* 16 bit commands */
  2296. +     void (*start)();
  2297. +     int (*done)();
  2298. + };
  2299. + 
  2300. + struct atapi_command_packet {
  2301. +     void *ad_link;
  2302. +     void *command;
  2303. +     char cmd_store[16];
  2304. +     int command_size;
  2305. +     struct buf* bp; 
  2306. +     void *databuf;
  2307. +     int data_size;
  2308. +     long flags;   /* handle B_READ/B_WRITE mask 0x00f00000 */
  2309. +                   /* controller flags maks 0x0000000f */
  2310. +                   /* ATAPI flags mask 0x000000f0 */
  2311. +                   /* Capabilities flags 0x00000f00 */
  2312. +     u_int8_t drive;
  2313. +     u_int16_t status;
  2314. + #define STATUS_MASK 0xff
  2315. + #define NO_ERROR 0x00
  2316. + #define ERROR 0x01
  2317. + #define MEDIA_CHANGE 0x02
  2318. + #define END_OF_MEDIA 0x03
  2319. + #define NOT_READY 0x10
  2320. + #define UNIT_ATTENTION 0x20
  2321. + #define RETRY 0x40
  2322. + #define ITSDONE 0x100
  2323. +     u_int8_t error;
  2324. +     u_int8_t retries;
  2325. + #define ATAPI_NRETRIES 5
  2326. +     LIST_ENTRY(atapi_command_packet) free_list;
  2327. + };
  2328. + 
  2329. + int wdc_atapi_get_params  __P((struct bus_link *,u_int8_t, struct atapi_identify *)); 
  2330. + void wdc_atapi_send_command_packet __P((struct bus_link*, struct atapi_command_packet*));
  2331. + #define A_POLLED 0x10
  2332. + #define A_NOSLEEP 0x20
  2333. + #define A_SILENT 0x40
  2334. + void atapi_done __P((struct atapi_command_packet *));
  2335. + struct atapi_command_packet *atapi_get_pkt __P((struct at_dev_link *, int));
  2336. + void atapi_free_pkt __P((struct atapi_command_packet *));
  2337. diff -c -r -N --exclude exp --exclude compile sys/atapi.orig/files.atapi sys/atapi/files.atapi
  2338. *** sys/atapi.orig/files.atapi    Thu Jan  1 01:00:00 1970
  2339. --- sys/atapi/files.atapi    Thu Jun 13 03:19:50 1996
  2340. ***************
  2341. *** 0 ****
  2342. --- 1,14 ----
  2343. + #
  2344. + # Config.new file and device description for machine-independent ATAPI code.
  2345. + # Included by ports that need it.  Ports that usee it must provide
  2346. + # their own "major" declarations for the appropriate devices.
  2347. + 
  2348. + define    atapi {}
  2349. + file    atapi/atapiconf.c            atapi
  2350. + 
  2351. + device    atapibus {drive = -1}
  2352. + attach    atapibus at atapi
  2353. + 
  2354. + device  acd: disk
  2355. + attach  acd at atapibus
  2356. + file    atapi/acd.c           acd needs-flag
  2357.