summaryrefslogtreecommitdiffstats
path: root/drivers/cdrom/cm206.c
blob: 4ee288688fed492378f87fb2f10c1fdcf587fe7d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
/* cm206.c. A linux-driver for the cm206 cdrom player with cm260 adapter card.
   Copyright (c) 1995--1997 David A. van Leeuwen.
   $Id: cm206.c,v 1.5 1997/12/26 11:02:51 david Exp $
   
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
     
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
     
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

History:
 Started 25 jan 1994. Waiting for documentation...
 22 feb 1995: 0.1a first reasonably safe polling driver.
	      Two major bugs, one in read_sector and one in 
	      do_cm206_request, happened to cancel!
 25 feb 1995: 0.2a first reasonable interrupt driven version of above.
              uart writes are still done in polling mode. 
 25 feb 1995: 0.21a writes also in interrupt mode, still some
	      small bugs to be found... Larger buffer. 
  2 mrt 1995: 0.22 Bug found (cd-> nowhere, interrupt was called in
              initialization), read_ahead of 16. Timeouts implemented.
	      unclear if they do something...
  7 mrt 1995: 0.23 Start of background read-ahead.
 18 mrt 1995: 0.24 Working background read-ahead. (still problems)
 26 mrt 1995: 0.25 Multi-session ioctl added (kernel v1.2).
              Statistics implemented, though separate stats206.h.
	      Accessible through ioctl 0x1000 (just a number).
	      Hard to choose between v1.2 development and 1.1.75.
	      Bottom-half doesn't work with 1.2...
	      0.25a: fixed... typo. Still problems...
  1 apr 1995: 0.26 Module support added. Most bugs found. Use kernel 1.2.n.
  5 apr 1995: 0.27 Auto-probe for the adapter card base address.
              Auto-probe for the adaptor card irq line.
  7 apr 1995: 0.28 Added lilo setup support for base address and irq.
              Use major number 32 (not in this source), officially
	      assigned to this driver.
  9 apr 1995: 0.29 Added very limited audio support. Toc_header, stop, pause,
              resume, eject. Play_track ignores track info, because we can't 
	      read a table-of-contents entry. Toc_entry is implemented
	      as a `placebo' function: always returns start of disc. 
  3 may 1995: 0.30 Audio support completed. The get_toc_entry function
              is implemented as a binary search. 
 15 may 1995: 0.31 More work on audio stuff. Workman is not easy to 
              satisfy; changed binary search into linear search.
	      Auto-probe for base address somewhat relaxed.
  1 jun 1995: 0.32 Removed probe_irq_on/off for module version.
 10 jun 1995: 0.33 Workman still behaves funny, but you should be
              able to eject and substitute another disc.

 An adaptation of 0.33 is included in linux-1.3.7 by Eberhard Moenkeberg

 18 jul 1995: 0.34 Patch by Heiko Eissfeldt included, mainly considering 
              verify_area's in the ioctls. Some bugs introduced by 
	      EM considering the base port and irq fixed. 

 18 dec 1995: 0.35 Add some code for error checking... no luck...

 We jump to reach our goal: version 1.0 in the next stable linux kernel.

 19 mar 1996: 0.95 Different implementation of CDROM_GET_UPC, on
	      request of Thomas Quinot. 
 25 mar 1996: 0.96 Interpretation of opening with O_WRONLY or O_RDWR:
	      open only for ioctl operation, e.g., for operation of
	      tray etc.
 4 apr 1996:  0.97 First implementation of layer between VFS and cdrom
              driver, a generic interface. Much of the functionality
	      of cm206_open() and cm206_ioctl() is transferred to a
	      new file cdrom.c and its header ucdrom.h. 

	      Upgrade to Linux kernel 1.3.78. 

 11 apr 1996  0.98 Upgrade to Linux kernel 1.3.85
              More code moved to cdrom.c
 
 	      0.99 Some more small changes to decrease number
 	      of oopses at module load; 
 
 27 jul 1996  0.100 Many hours of debugging, kernel change from 1.2.13
	      to 2.0.7 seems to have introduced some weird behavior
	      in (interruptible_)sleep_on(&cd->data): the process
	      seems to be woken without any explicit wake_up in my own
	      code. Patch to try 100x in case such untriggered wake_up's 
	      occur. 

 28 jul 1996  0.101 Rewriting of the code that receives the command echo,
	      using a fifo to store echoed bytes. 

 	      Branch from 0.99:
 
 	      0.99.1.0 Update to kernel release 2.0.10 dev_t -> kdev_t
 	      (emoenke) various typos found by others.  extra
 	      module-load oops protection.
 
 	      0.99.1.1 Initialization constant cdrom_dops.speed
 	      changed from float (2.0) to int (2); Cli()-sti() pair
 	      around cm260_reset() in module initialization code.
 
 	      0.99.1.2 Changes literally as proposed by Scott Snyder
 	      <snyder@d0sgif.fnal.gov> for the 2.1 kernel line, which
 	      have to do mainly with the poor minor support i had. The
 	      major new concept is to change a cdrom driver's
 	      operations struct from the capabilities struct. This
 	      reflects the fact that there is one major for a driver,
 	      whilst there can be many minors whith completely
 	      different capabilities.

	      0.99.1.3 More changes for operations/info separation.

	      0.99.1.4 Added speed selection (someone had to do this
	      first).

  23 jan 1997 0.99.1.5 MODULE_PARMS call added.

  23 jan 1997 0.100.1.2--0.100.1.5 following similar lines as 
  	      0.99.1.1--0.99.1.5. I get too many complaints about the
	      drive making read errors. What't wrong with the 2.0+
	      kernel line? Why get i (and othe cm206 owners) weird
	      results? Why were things good in the good old 1.1--1.2 
	      era? Why don't i throw away the drive?

 2 feb 1997   0.102 Added `volatile' to values in cm206_struct. Seems to 
 	      reduce many of the problems. Rewrote polling routines
	      to use fixed delays between polls. 
	      0.103 Changed printk behavior. 
	      0.104 Added a 0.100 -> 0.100.1.1 change

11 feb 1997   0.105 Allow auto_probe during module load, disable
              with module option "auto_probe=0". Moved some debugging
	      statements to lower priority. Implemented select_speed()
	      function. 

13 feb 1997   1.0 Final version for 2.0 kernel line. 

	      All following changes will be for the 2.1 kernel line. 

15 feb 1997   1.1 Keep up with kernel 2.1.26, merge in changes from 
              cdrom.c 0.100.1.1--1.0. Add some more MODULE_PARMS. 

14 sep 1997   1.2 Upgrade to Linux 2.1.55.  Added blksize_size[], patch
              sent by James Bottomley <James.Bottomley@columbiasc.ncr.com>.

21 dec 1997   1.4 Upgrade to Linux 2.1.72.  

24 jan 1998   Removed the cm206_disc_status() function, as it was now dead
              code.  The Uniform CDROM driver now provides this functionality.
	      
9 Nov. 1999   Make kernel-parameter implementation work with 2.3.x 
	      Removed init_module & cleanup_module in favor of 
	      module_init & module_exit.
	      Torben Mathiasen <tmm@image.dk>
 * 
 * Parts of the code are based upon lmscd.c written by Kai Petzke,
 * sbpcd.c written by Eberhard Moenkeberg, and mcd.c by Martin
 * Harriss, but any off-the-shelf dynamic programming algorithm won't
 * be able to find them.
 *
 * The cm206 drive interface and the cm260 adapter card seem to be 
 * sufficiently different from their cm205/cm250 counterparts
 * in order to write a complete new driver.
 * 
 * I call all routines connected to the Linux kernel something
 * with `cm206' in it, as this stuff is too series-dependent. 
 * 
 * Currently, my limited knowledge is based on:
 * - The Linux Kernel Hacker's guide, v. 0.5, by Michael K. Johnson
 * - Linux Kernel Programmierung, by Michael Beck and others
 * - Philips/LMS cm206 and cm226 product specification
 * - Philips/LMS cm260 product specification
 *
 * David van Leeuwen, david@tm.tno.nl.  */
#define REVISION "$Revision: 1.5 $"

#include <linux/module.h>

#include <linux/errno.h>	/* These include what we really need */
#include <linux/delay.h>
#include <linux/string.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/timer.h>
#include <linux/cdrom.h>
#include <linux/ioport.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/init.h>

/* #include <linux/ucdrom.h> */

#include <asm/io.h>

#define MAJOR_NR CM206_CDROM_MAJOR

#include <linux/blkdev.h>

#undef DEBUG
#define STATISTICS		/* record times and frequencies of events */
#define AUTO_PROBE_MODULE
#define USE_INSW

#include "cm206.h"

/* This variable defines whether or not to probe for adapter base port 
   address and interrupt request. It can be overridden by the boot 
   parameter `auto'.
*/
static int auto_probe = 1;	/* Yes, why not? */

static int cm206_base = CM206_BASE;
static int cm206_irq = CM206_IRQ;
#ifdef MODULE
static int cm206[2] = { 0, 0 };	/* for compatible `insmod' parameter passing */
module_param_array(cm206, int, NULL, 0);	/* base,irq or irq,base */
#endif

module_param(cm206_base, int, 0);	/* base */
module_param(cm206_irq, int, 0);	/* irq */
module_param(auto_probe, bool, 0);	/* auto probe base and irq */
MODULE_LICENSE("GPL");

#define POLLOOP 100		/* milliseconds */
#define READ_AHEAD 1		/* defines private buffer, waste! */
#define BACK_AHEAD 1		/* defines adapter-read ahead */
#define DATA_TIMEOUT (3*HZ)	/* measured in jiffies (10 ms) */
#define UART_TIMEOUT (5*HZ/100)
#define DSB_TIMEOUT (7*HZ)	/* time for the slowest command to finish */
#define UR_SIZE 4		/* uart receive buffer fifo size */

#define LINUX_BLOCK_SIZE 512	/* WHERE is this defined? */
#define RAW_SECTOR_SIZE 2352	/* ok, is also defined in cdrom.h */
#define ISO_SECTOR_SIZE 2048
#define BLOCKS_ISO (ISO_SECTOR_SIZE/LINUX_BLOCK_SIZE)	/* 4 */
#define CD_SYNC_HEAD 16		/* CD_SYNC + CD_HEAD */

#ifdef STATISTICS		/* keep track of errors in counters */
#define stats(i) { ++cd->stats[st_ ## i]; \
		     cd->last_stat[st_ ## i] = cd->stat_counter++; \
		 }
#else
#define stats(i) (void) 0;
#endif

#define Debug(a) {printk (KERN_DEBUG); printk a;}
#ifdef DEBUG
#define debug(a) Debug(a)
#else
#define debug(a) (void) 0;
#endif

typedef unsigned char uch;	/* 8-bits */
typedef unsigned short ush;	/* 16-bits */

struct toc_struct {		/* private copy of Table of Contents */
	uch track, fsm[3], q0;
};

struct cm206_struct {
	volatile ush intr_ds;	/* data status read on last interrupt */
	volatile ush intr_ls;	/* uart line status read on last interrupt */
	volatile uch ur[UR_SIZE];	/* uart receive buffer fifo */
	volatile uch ur_w, ur_r;	/* write/read buffer index */
	volatile uch dsb, cc;	/* drive status byte and condition (error) code */
	int command;		/* command to be written to the uart */
	int openfiles;
	ush sector[READ_AHEAD * RAW_SECTOR_SIZE / 2];	/* buffered cd-sector */
	int sector_first, sector_last;	/* range of these sectors */
	wait_queue_head_t uart;	/* wait queues for interrupt */
	wait_queue_head_t data;
	struct timer_list timer;	/* time-out */
	char timed_out;
	signed char max_sectors;	/* number of sectors that fit in adapter mem */
	char wait_back;		/* we're waiting for a background-read */
	char background;	/* is a read going on in the background? */
	int adapter_first;	/* if so, that's the starting sector */
	int adapter_last;
	char fifo_overflowed;
	uch disc_status[7];	/* result of get_disc_status command */
#ifdef STATISTICS
	int stats[NR_STATS];
	int last_stat[NR_STATS];	/* `time' at which stat was stat */
	int stat_counter;
#endif
	struct toc_struct toc[101];	/* The whole table of contents + lead-out */
	uch q[10];		/* Last read q-channel info */
	uch audio_status[5];	/* last read position on pause */
	uch media_changed;	/* record if media changed */
};

#define DISC_STATUS cd->disc_status[0]
#define FIRST_TRACK cd->disc_status[1]
#define LAST_TRACK cd->disc_status[2]
#define PAUSED cd->audio_status[0]	/* misuse this memory byte! */
#define PLAY_TO cd->toc[0]	/* toc[0] records end-time in play */

static struct cm206_struct *cd;	/* the main memory structure */
static struct request_queue *cm206_queue;
static DEFINE_SPINLOCK(cm206_lock);

/* First, we define some polling functions. These are actually
   only being used in the initialization. */

static void send_command_polled(int command)
{
	int loop = POLLOOP;
	while (!(inw(r_line_status) & ls_transmitter_buffer_empty)
	       && loop > 0) {
		mdelay(1);	/* one millisec delay */
		--loop;
	}
	outw(command, r_uart_transmit);
}

static uch receive_echo_polled(void)
{
	int loop = POLLOOP;
	while (!(inw(r_line_status) & ls_receive_buffer_full) && loop > 0) {
		mdelay(1);
		--loop;
	}
	return ((uch) inw(r_uart_receive));
}

static uch send_receive_polled(int command)
{
	send_command_polled(command);
	return receive_echo_polled();
}

static inline void clear_ur(void)
{
	if (cd->ur_r != cd->ur_w) {
		debug(("Deleting bytes from fifo:"));
		for (; cd->ur_r != cd->ur_w;
		     cd->ur_r++, cd->ur_r %= UR_SIZE)
			debug((" 0x%x", cd->ur[cd->ur_r]));
		debug(("\n"));
	}
}

static struct tasklet_struct cm206_tasklet;

/* The interrupt handler. When the cm260 generates an interrupt, very
   much care has to be taken in reading out the registers in the right
   order; in case of a receive_buffer_full interrupt, first the
   uart_receive must be read, and then the line status again to
   de-assert the interrupt line. It took me a couple of hours to find
   this out:-( 

   The function reset_cm206 appears to cause an interrupt, because
   pulling up the INIT line clears both the uart-write-buffer /and/
   the uart-write-buffer-empty mask. We call this a `lost interrupt,'
   as there seems so reason for this to happen.
*/

static irqreturn_t cm206_interrupt(int sig, void *dev_id, struct pt_regs *regs)
{
	volatile ush fool;
	cd->intr_ds = inw(r_data_status);	/* resets data_ready, data_error,
						   crc_error, sync_error, toc_ready 
						   interrupts */
	cd->intr_ls = inw(r_line_status);	/* resets overrun bit */
	debug(("Intr, 0x%x 0x%x, %d\n", cd->intr_ds, cd->intr_ls,
	       cd->background));
	if (cd->intr_ls & ls_attention)
		stats(attention);
	/* receive buffer full? */
	if (cd->intr_ls & ls_receive_buffer_full) {
		cd->ur[cd->ur_w] = inb(r_uart_receive);	/* get order right! */
		cd->intr_ls = inw(r_line_status);	/* resets rbf interrupt */
		debug(("receiving #%d: 0x%x\n", cd->ur_w,
		       cd->ur[cd->ur_w]));
		cd->ur_w++;
		cd->ur_w %= UR_SIZE;
		if (cd->ur_w == cd->ur_r)
			debug(("cd->ur overflow!\n"));
		if (waitqueue_active(&cd->uart) && cd->background < 2) {
			del_timer(&cd->timer);
			wake_up_interruptible(&cd->uart);
		}
	}
	/* data ready in fifo? */
	else if (cd->intr_ds & ds_data_ready) {
		if (cd->background)
			++cd->adapter_last;
		if (waitqueue_active(&cd->data)
		    && (cd->wait_back || !cd->background)) {
			del_timer(&cd->timer);
			wake_up_interruptible(&cd->data);
		}
		stats(data_ready);
	}
	/* ready to issue a write command? */
	else if (cd->command && cd->intr_ls & ls_transmitter_buffer_empty) {
		outw(dc_normal | (inw(r_data_status) & 0x7f),
		     r_data_control);
		outw(cd->command, r_uart_transmit);
		cd->command = 0;
		if (!cd->background)
			wake_up_interruptible(&cd->uart);
	}
	/* now treat errors (at least, identify them for debugging) */
	else if (cd->intr_ds & ds_fifo_overflow) {
		debug(("Fifo overflow at sectors 0x%x\n",
		       cd->sector_first));
		fool = inw(r_fifo_output_buffer);	/* de-assert the interrupt */
		cd->fifo_overflowed = 1;	/* signal one word less should be read */
		stats(fifo_overflow);
	} else if (cd->intr_ds & ds_data_error) {
		debug(("Data error at sector 0x%x\n", cd->sector_first));
		stats(data_error);
	} else if (cd->intr_ds & ds_crc_error) {
		debug(("CRC error at sector 0x%x\n", cd->sector_first));
		stats(crc_error);
	} else if (cd->intr_ds & ds_sync_error) {
		debug(("Sync at sector 0x%x\n", cd->sector_first));
		stats(sync_error);
	} else if (cd->intr_ds & ds_toc_ready) {
		/* do something appropriate */
	}
	/* couldn't see why this interrupt, maybe due to init */
	else {
		outw(dc_normal | READ_AHEAD, r_data_control);
		stats(lost_intr);
	}
	if (cd->background
	    && (cd->adapter_last - cd->adapter_first == cd->max_sectors
		|| cd->fifo_overflowed))
		tasklet_schedule(&cm206_tasklet);	/* issue a stop read command */
	stats(interrupt);
	return IRQ_HANDLED;
}

/* we have put the address of the wait queue in who */
static void cm206_timeout(unsigned long who)
{
	cd->timed_out = 1;
	debug(("Timing out\n"));
	wake_up_interruptible((wait_queue_head_t *) who);
}

/* This function returns 1 if a timeout occurred, 0 if an interrupt
   happened */
static int sleep_or_timeout(wait_queue_head_t * wait, int timeout)
{
	cd->timed_out = 0;
	init_timer(&cd->timer);
	cd->timer.data = (unsigned long) wait;
	cd->timer.expires = jiffies + timeout;
	add_timer(&cd->timer);
	debug(("going to sleep\n"));
	interruptible_sleep_on(wait);
	del_timer(&cd->timer);
	if (cd->timed_out) {
		cd->timed_out = 0;
		return 1;
	} else
		return 0;
}

static void send_command(int command)
{
	debug(("Sending 0x%x\n", command));
	if (!(inw(r_line_status) & ls_transmitter_buffer_empty)) {
		cd->command = command;
		cli();		/* don't interrupt before sleep */
		outw(dc_mask_sync_error | dc_no_stop_on_error |
		     (inw(r_data_status) & 0x7f), r_data_control);
		/* interrupt routine sends command */
		if (sleep_or_timeout(&cd->uart, UART_TIMEOUT)) {
			debug(("Time out on write-buffer\n"));
			stats(write_timeout);
			outw(command, r_uart_transmit);
		}
		debug(("Write commmand delayed\n"));
	} else
		outw(command, r_uart_transmit);
}

static uch receive_byte(int timeout)
{
	uch ret;
	cli();
	debug(("cli\n"));
	ret = cd->ur[cd->ur_r];
	if (cd->ur_r != cd->ur_w) {
		sti();
		debug(("returning #%d: 0x%x\n", cd->ur_r,
		       cd->ur[cd->ur_r]));
		cd->ur_r++;
		cd->ur_r %= UR_SIZE;
		return ret;
	} else if (sleep_or_timeout(&cd->uart, timeout)) {	/* does sti() */
		debug(("Time out on receive-buffer\n"));
#ifdef STATISTICS
		if (timeout == UART_TIMEOUT)
			stats(receive_timeout)	/* no `;'! */
			    else
			stats(dsb_timeout);
#endif
		return 0xda;
	}
	ret = cd->ur[cd->ur_r];
	debug(("slept; returning #%d: 0x%x\n", cd->ur_r,
	       cd->ur[cd->ur_r]));
	cd->ur_r++;
	cd->ur_r %= UR_SIZE;
	return ret;
}

static inline uch receive_echo(void)
{
	return receive_byte(UART_TIMEOUT);
}

static inline uch send_receive(int command)
{
	send_command(command);
	return receive_echo();
}

static inline uch wait_dsb(void)
{
	return receive_byte(DSB_TIMEOUT);
}

static int type_0_command(int command, int expect_dsb)
{
	int e;
	clear_ur();
	if (command != (e = send_receive(command))) {
		debug(("command 0x%x echoed as 0x%x\n", command, e));
		stats(echo);
		return -1;
	}
	if (expect_dsb) {
		cd->dsb = wait_dsb();	/* wait for command to finish */
	}
	return 0;
}

static int type_1_command(int command, int bytes, uch * status)
{				/* returns info */
	int i;
	if (type_0_command(command, 0))
		return -1;
	for (i = 0; i < bytes; i++)
		status[i] = send_receive(c_gimme);
	return 0;
}

/* This function resets the adapter card. We'd better not do this too
 * often, because it tends to generate `lost interrupts.' */
static void reset_cm260(void)
{
	outw(dc_normal | dc_initialize | READ_AHEAD, r_data_control);
	udelay(10);		/* 3.3 mu sec minimum */
	outw(dc_normal | READ_AHEAD, r_data_control);
}

/* fsm: frame-sec-min from linear address; one of many */
static void fsm(int lba, uch * fsm)
{
	fsm[0] = lba % 75;
	lba /= 75;
	lba += 2;
	fsm[1] = lba % 60;
	fsm[2] = lba / 60;
}

static inline int fsm2lba(uch * fsm)
{
	return fsm[0] + 75 * (fsm[1] - 2 + 60 * fsm[2]);
}

static inline int f_s_m2lba(uch f, uch s, uch m)
{
	return f + 75 * (s - 2 + 60 * m);
}

static int start_read(int start)
{
	uch read_sector[4] = { c_read_data, };
	int i, e;

	fsm(start, &read_sector[1]);
	clear_ur();
	for (i = 0; i < 4; i++)
		if (read_sector[i] != (e = send_receive(read_sector[i]))) {
			debug(("read_sector: %x echoes %x\n",
			       read_sector[i], e));
			stats(echo);
			if (e == 0xff) {	/* this seems to happen often */
				e = receive_echo();
				debug(("Second try %x\n", e));
				if (e != read_sector[i])
					return -1;
			}
		}
	return 0;
}

static int stop_read(void)
{
	int e;
	type_0_command(c_stop, 0);
	if ((e = receive_echo()) != 0xff) {
		debug(("c_stop didn't send 0xff, but 0x%x\n", e));
		stats(stop_0xff);
		return -1;
	}
	return 0;
}

/* This function starts to read sectors in adapter memory, the
   interrupt routine should stop the read. In fact, the bottom_half
   routine takes care of this. Set a flag `background' in the cd
   struct to indicate the process. */

static int read_background(int start, int reading)
{
	if (cd->background)
		return -1;	/* can't do twice */
	outw(dc_normal | BACK_AHEAD, r_data_control);
	if (!reading && start_read(start))
		return -2;
	cd->adapter_first = cd->adapter_last = start;
	cd->background = 1;	/* flag a read is going on */
	return 0;
}

#ifdef USE_INSW
#define transport_data insw
#else
/* this routine implements insw(,,). There was a time i had the
   impression that there would be any difference in error-behaviour. */
void transport_data(int port, ush * dest, int count)
{
	int i;
	ush *d;
	for (i = 0, d = dest; i < count; i++, d++)
		*d = inw(port);
}
#endif


#define MAX_TRIES 100
static int read_sector(int start)
{
	int tries = 0;
	if (cd->background) {
		cd->background = 0;
		cd->adapter_last = -1;	/* invalidate adapter memory */
		stop_read();
	}
	cd->fifo_overflowed = 0;
	reset_cm260();		/* empty fifo etc. */
	if (start_read(start))
		return -1;
	do {
		if (sleep_or_timeout(&cd->data, DATA_TIMEOUT)) {
			debug(("Read timed out sector 0x%x\n", start));
			stats(read_timeout);
			stop_read();
			return -3;
		}
		tries++;
	} while (cd->intr_ds & ds_fifo_empty && tries < MAX_TRIES);
	if (tries > 1)
		debug(("Took me some tries\n"))
		    else
	if (tries == MAX_TRIES)
		debug(("MAX_TRIES tries for read sector\n"));
	transport_data(r_fifo_output_buffer, cd->sector,
		       READ_AHEAD * RAW_SECTOR_SIZE / 2);
	if (read_background(start + READ_AHEAD, 1))
		stats(read_background);
	cd->sector_first = start;
	cd->sector_last = start + READ_AHEAD;
	stats(read_restarted);
	return 0;
}

/* The function of bottom-half is to send a stop command to the drive
   This isn't easy because the routine is not `owned' by any process;
   we can't go to sleep! The variable cd->background gives the status:
   0 no read pending
   1 a read is pending
   2 c_stop waits for write_buffer_empty
   3 c_stop waits for receive_buffer_full: echo
   4 c_stop waits for receive_buffer_full: 0xff
*/

static void cm206_tasklet_func(unsigned long ignore)
{
	debug(("bh: %d\n", cd->background));
	switch (cd->background) {
	case 1:
		stats(bh);
		if (!(cd->intr_ls & ls_transmitter_buffer_empty)) {
			cd->command = c_stop;
			outw(dc_mask_sync_error | dc_no_stop_on_error |
			     (inw(r_data_status) & 0x7f), r_data_control);
			cd->background = 2;
			break;	/* we'd better not time-out here! */
		} else
			outw(c_stop, r_uart_transmit);
		/* fall into case 2: */
	case 2:
		/* the write has been satisfied by interrupt routine */
		cd->background = 3;
		break;
	case 3:
		if (cd->ur_r != cd->ur_w) {
			if (cd->ur[cd->ur_r] != c_stop) {
				debug(("cm206_bh: c_stop echoed 0x%x\n",
				       cd->ur[cd->ur_r]));
				stats(echo);
			}
			cd->ur_r++;
			cd->ur_r %= UR_SIZE;
		}
		cd->background++;
		break;
	case 4:
		if (cd->ur_r != cd->ur_w) {
			if (cd->ur[cd->ur_r] != 0xff) {
				debug(("cm206_bh: c_stop reacted with 0x%x\n", cd->ur[cd->ur_r]));
				stats(stop_0xff);
			}
			cd->ur_r++;
			cd->ur_r %= UR_SIZE;
		}
		cd->background = 0;
	}
}

static DECLARE_TASKLET(cm206_tasklet, cm206_tasklet_func, 0);

/* This command clears the dsb_possible_media_change flag, so we must 
 * retain it.
 */
static void get_drive_status(void)
{
	uch status[2];
	type_1_command(c_drive_status, 2, status);	/* this might be done faster */
	cd->dsb = status[0];
	cd->cc = status[1];
	cd->media_changed |=
	    !!(cd->dsb & (dsb_possible_media_change |
			  dsb_drive_not_ready | dsb_tray_not_closed));
}

static void get_disc_status(void)
{
	if (type_1_command(c_disc_status, 7, cd->disc_status)) {
		debug(("get_disc_status: error\n"));
	}
}

/* The new open. The real opening strategy is defined in cdrom.c. */

static int cm206_open(struct cdrom_device_info *cdi, int purpose)
{
	if (!cd->openfiles) {	/* reset only first time */
		cd->background = 0;
		reset_cm260();
		cd->adapter_last = -1;	/* invalidate adapter memory */
		cd->sector_last = -1;
	}
	++cd->openfiles;
	stats(open);
	return 0;
}

static void cm206_release(struct cdrom_device_info *cdi)
{
	if (cd->openfiles == 1) {
		if (cd->background) {
			cd->background = 0;
			stop_read();
		}
		cd->sector_last = -1;	/* Make our internal buffer invalid */
		FIRST_TRACK = 0;	/* No valid disc status */
	}
	--cd->openfiles;
}

/* Empty buffer empties $sectors$ sectors of the adapter card buffer,
 * and then reads a sector in kernel memory.  */
static void empty_buffer(int sectors)
{
	while (sectors >= 0) {
		transport_data(r_fifo_output_buffer,
			       cd->sector + cd->fifo_overflowed,
			       RAW_SECTOR_SIZE / 2 - cd->fifo_overflowed);
		--sectors;
		++cd->adapter_first;	/* update the current adapter sector */
		cd->fifo_overflowed = 0;	/* reset overflow bit */
		stats(sector_transferred);
	}
	cd->sector_first = cd->adapter_first - 1;
	cd->sector_last = cd->adapter_first;	/* update the buffer sector */
}

/* try_adapter. This function determines if the requested sector is
   in adapter memory, or will appear there soon. Returns 0 upon
   success */
static int try_adapter(int sector)
{
	if (cd->adapter_first <= sector && sector < cd->adapter_last) {
		/* sector is in adapter memory */
		empty_buffer(sector - cd->adapter_first);
		return 0;
	} else if (cd->background == 1 && cd->adapter_first <= sector
		   && sector < cd->adapter_first + cd->max_sectors) {
		/* a read is going on, we can wait for it */
		cd->wait_back = 1;
		while (sector >= cd->adapter_last) {
			if (sleep_or_timeout(&cd->data, DATA_TIMEOUT)) {
				debug(("Timed out during background wait: %d %d %d %d\n", sector, cd->adapter_last, cd->adapter_first, cd->background));
				stats(back_read_timeout);
				cd->wait_back = 0;
				return -1;
			}
		}
		cd->wait_back = 0;
		empty_buffer(sector - cd->adapter_first);
		return 0;
	} else
		return -2;
}

/* This is not a very smart implementation. We could optimize for 
   consecutive block numbers. I'm not convinced this would really
   bring down the processor load. */
static void do_cm206_request(request_queue_t * q)
{
	long int i, cd_sec_no;
	int quarter, error;
	uch *source, *dest;
	struct request *req;

	while (1) {	/* repeat until all requests have been satisfied */
		req = elv_next_request(q);
		if (!req)
			return;

		if (req->cmd != READ) {
			debug(("Non-read command %d on cdrom\n", req->cmd));
			end_request(req, 0);
			continue;
		}
		spin_unlock_irq(q->queue_lock);
		error = 0;
		for (i = 0; i < req->nr_sectors; i++) {
			int e1, e2;
			cd_sec_no = (req->sector + i) / BLOCKS_ISO;	/* 4 times 512 bytes */
			quarter = (req->sector + i) % BLOCKS_ISO;
			dest = req->buffer + i * LINUX_BLOCK_SIZE;
			/* is already in buffer memory? */
			if (cd->sector_first <= cd_sec_no
			    && cd_sec_no < cd->sector_last) {
				source =
				    ((uch *) cd->sector) + 16 +
				    quarter * LINUX_BLOCK_SIZE +
				    (cd_sec_no -
				     cd->sector_first) * RAW_SECTOR_SIZE;
				memcpy(dest, source, LINUX_BLOCK_SIZE);
			} else if (!(e1 = try_adapter(cd_sec_no)) ||
				   !(e2 = read_sector(cd_sec_no))) {
				source =
				    ((uch *) cd->sector) + 16 +
				    quarter * LINUX_BLOCK_SIZE;
				memcpy(dest, source, LINUX_BLOCK_SIZE);
			} else {
				error = 1;
				debug(("cm206_request: %d %d\n", e1, e2));
			}
		}
		spin_lock_irq(q->queue_lock);
		end_request(req, !error);
	}
}

/* Audio support. I've tried very hard, but the cm206 drive doesn't 
   seem to have a get_toc (table-of-contents) function, while i'm
   pretty sure it must read the toc upon disc insertion. Therefore
   this function has been implemented through a binary search 
   strategy. All track starts that happen to be found are stored in
   cd->toc[], for future use. 

   I've spent a whole day on a bug that only shows under Workman---
   I don't get it. Tried everything, nothing works. If workman asks
   for track# 0xaa, it'll get the wrong time back. Any other program
   receives the correct value. I'm stymied.
*/

/* seek seeks to address lba. It does wait to arrive there. */
static void seek(int lba)
{
	int i;
	uch seek_command[4] = { c_seek, };

	fsm(lba, &seek_command[1]);
	for (i = 0; i < 4; i++)
		type_0_command(seek_command[i], 0);
	cd->dsb = wait_dsb();
}

uch bcdbin(unsigned char bcd)
{				/* stolen from mcd.c! */
	return (bcd >> 4) * 10 + (bcd & 0xf);
}

static inline uch normalize_track(uch track)
{
	if (track < 1)
		return 1;
	if (track > LAST_TRACK)
		return LAST_TRACK + 1;
	return track;
}

/* This function does a binary search for track start. It records all
 * tracks seen in the process. Input $track$ must be between 1 and
 * #-of-tracks+1.  Note that the start of the disc must be in toc[1].fsm. 
 */
static int get_toc_lba(uch track)
{
	int max = 74 * 60 * 75 - 150, min = fsm2lba(cd->toc[1].fsm);
	int i, lba, l, old_lba = 0;
	uch *q = cd->q;
	uch ct;			/* current track */
	int binary = 0;
	const int skip = 3 * 60 * 75;	/* 3 minutes */

	for (i = track; i > 0; i--)
		if (cd->toc[i].track) {
			min = fsm2lba(cd->toc[i].fsm);
			break;
		}
	lba = min + skip;
	do {
		seek(lba);
		type_1_command(c_read_current_q, 10, q);
		ct = normalize_track(q[1]);
		if (!cd->toc[ct].track) {
			l = q[9] - bcdbin(q[5]) + 75 * (q[8] -
							bcdbin(q[4]) - 2 +
							60 * (q[7] -
							      bcdbin(q
								     [3])));
			cd->toc[ct].track = q[1];	/* lead out still 0xaa */
			fsm(l, cd->toc[ct].fsm);
			cd->toc[ct].q0 = q[0];	/* contains adr and ctrl info */
			if (ct == track)
				return l;
		}
		old_lba = lba;
		if (binary) {
			if (ct < track)
				min = lba;
			else
				max = lba;
			lba = (min + max) / 2;
		} else {
			if (ct < track)
				lba += skip;
			else {
				binary = 1;
				max = lba;
				min = lba - skip;
				lba = (min + max) / 2;
			}
		}
	} while (lba != old_lba);
	return lba;
}

static void update_toc_entry(uch track)
{
	track = normalize_track(track);
	if (!cd->toc[track].track)
		get_toc_lba(track);
}

/* return 0 upon success */
static int read_toc_header(struct cdrom_tochdr *hp)
{
	if (!FIRST_TRACK)
		get_disc_status();
	if (hp) {
		int i;
		hp->cdth_trk0 = FIRST_TRACK;
		hp->cdth_trk1 = LAST_TRACK;
		/* fill in first track position */
		for (i = 0; i < 3; i++)
			cd->toc[1].fsm[i] = cd->disc_status[3 + i];
		update_toc_entry(LAST_TRACK + 1);	/* find most entries */
		return 0;
	}
	return -1;
}

static void play_from_to_msf(struct cdrom_msf *msfp)
{
	uch play_command[] = { c_play,
		msfp->cdmsf_frame0, msfp->cdmsf_sec0, msfp->cdmsf_min0,
		msfp->cdmsf_frame1, msfp->cdmsf_sec1, msfp->cdmsf_min1, 2,
		    2
	};
	int i;
	for (i = 0; i < 9; i++)
		type_0_command(play_command[i], 0);
	for (i = 0; i < 3; i++)
		PLAY_TO.fsm[i] = play_command[i + 4];
	PLAY_TO.track = 0;	/* say no track end */
	cd->dsb = wait_dsb();
}

static void play_from_to_track(int from, int to)
{
	uch play_command[8] = { c_play, };
	int i;

	if (from == 0) {	/* continue paused play */
		for (i = 0; i < 3; i++) {
			play_command[i + 1] = cd->audio_status[i + 2];
			play_command[i + 4] = PLAY_TO.fsm[i];
		}
	} else {
		update_toc_entry(from);
		update_toc_entry(to + 1);
		for (i = 0; i < 3; i++) {
			play_command[i + 1] = cd->toc[from].fsm[i];
			PLAY_TO.fsm[i] = play_command[i + 4] =
			    cd->toc[to + 1].fsm[i];
		}
		PLAY_TO.track = to;
	}
	for (i = 0; i < 7; i++)
		type_0_command(play_command[i], 0);
	for (i = 0; i < 2; i++)
		type_0_command(0x2, 0);	/* volume */
	cd->dsb = wait_dsb();
}

static int get_current_q(struct cdrom_subchnl *qp)
{
	int i;
	uch *q = cd->q;
	if (type_1_command(c_read_current_q, 10, q))
		return 0;
/*  q[0] = bcdbin(q[0]); Don't think so! */
	for (i = 2; i < 6; i++)
		q[i] = bcdbin(q[i]);
	qp->cdsc_adr = q[0] & 0xf;
	qp->cdsc_ctrl = q[0] >> 4;	/* from mcd.c */
	qp->cdsc_trk = q[1];
	qp->cdsc_ind = q[2];
	if (qp->cdsc_format == CDROM_MSF) {
		qp->cdsc_reladdr.msf.minute = q[3];
		qp->cdsc_reladdr.msf.second = q[4];
		qp->cdsc_reladdr.msf.frame = q[5];
		qp->cdsc_absaddr.msf.minute = q[7];
		qp->cdsc_absaddr.msf.second = q[8];
		qp->cdsc_absaddr.msf.frame = q[9];
	} else {
		qp->cdsc_reladdr.lba = f_s_m2lba(q[5], q[4], q[3]);
		qp->cdsc_absaddr.lba = f_s_m2lba(q[9], q[8], q[7]);
	}
	get_drive_status();
	if (cd->dsb & dsb_play_in_progress)
		qp->cdsc_audiostatus = CDROM_AUDIO_PLAY;
	else if (PAUSED)
		qp->cdsc_audiostatus = CDROM_AUDIO_PAUSED;
	else
		qp->cdsc_audiostatus = CDROM_AUDIO_NO_STATUS;
	return 0;
}

static void invalidate_toc(void)
{
	memset(cd->toc, 0, sizeof(cd->toc));
	memset(cd->disc_status, 0, sizeof(cd->disc_status));
}

/* cdrom.c guarantees that cdte_format == CDROM_MSF */
static void get_toc_entry(struct cdrom_tocentry *ep)
{
	uch track = normalize_track(ep->cdte_track);
	update_toc_entry(track);
	ep->cdte_addr.msf.frame = cd->toc[track].fsm[0];
	ep->cdte_addr.msf.second = cd->toc[track].fsm[1];
	ep->cdte_addr.msf.minute = cd->toc[track].fsm[2];
	ep->cdte_adr = cd->toc[track].q0 & 0xf;
	ep->cdte_ctrl = cd->toc[track].q0 >> 4;
	ep->cdte_datamode = 0;
}

/* Audio ioctl.  Ioctl commands connected to audio are in such an
 * idiosyncratic i/o format, that we leave these untouched. Return 0
 * upon success. Memory checking has been done by cdrom_ioctl(), the
 * calling function, as well as LBA/MSF sanitization.
*/
static int cm206_audio_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
			     void *arg)
{
	switch (cmd) {
	case CDROMREADTOCHDR:
		return read_toc_header((struct cdrom_tochdr *) arg);
	case CDROMREADTOCENTRY:
		get_toc_entry((struct cdrom_tocentry *) arg);
		return 0;
	case CDROMPLAYMSF:
		play_from_to_msf((struct cdrom_msf *) arg);
		return 0;
	case CDROMPLAYTRKIND:	/* admittedly, not particularly beautiful */
		play_from_to_track(((struct cdrom_ti *) arg)->cdti_trk0,
				   ((struct cdrom_ti *) arg)->cdti_trk1);
		return 0;
	case CDROMSTOP:
		PAUSED = 0;
		if (cd->dsb & dsb_play_in_progress)
			return type_0_command(c_stop, 1);
		else
			return 0;
	case CDROMPAUSE:
		get_drive_status();
		if (cd->dsb & dsb_play_in_progress) {
			type_0_command(c_stop, 1);
			type_1_command(c_audio_status, 5,
				       cd->audio_status);
			PAUSED = 1;	/* say we're paused */
		}
		return 0;
	case CDROMRESUME:
		if (PAUSED)
			play_from_to_track(0, 0);
		PAUSED = 0;
		return 0;
	case CDROMSTART:
	case CDROMVOLCTRL:
		return 0;
	case CDROMSUBCHNL:
		return get_current_q((struct cdrom_subchnl *) arg);
	default:
		return -EINVAL;
	}
}

static int cm206_media_changed(struct cdrom_device_info *cdi, int disc_nr)
{
	if (cd != NULL) {
		int r;
		get_drive_status();	/* ensure cd->media_changed OK */
		r = cd->media_changed;
		cd->media_changed = 0;	/* clear bit */
		return r;
	} else
		return -EIO;
}

/* The new generic cdrom support. Routines should be concise, most of
   the logic should be in cdrom.c */


/* controls tray movement */
static int cm206_tray_move(struct cdrom_device_info *cdi, int position)
{
	if (position) {		/* 1: eject */
		type_0_command(c_open_tray, 1);
		invalidate_toc();
	} else
		type_0_command(c_close_tray, 1);	/* 0: close */
	return 0;
}

/* gives current state of the drive */
static int cm206_drive_status(struct cdrom_device_info *cdi, int slot_nr)
{
	get_drive_status();
	if (cd->dsb & dsb_tray_not_closed)
		return CDS_TRAY_OPEN;
	if (!(cd->dsb & dsb_disc_present))
		return CDS_NO_DISC;
	if (cd->dsb & dsb_drive_not_ready)
		return CDS_DRIVE_NOT_READY;
	return CDS_DISC_OK;
}

/* locks or unlocks door lock==1: lock; return 0 upon success */
static int cm206_lock_door(struct cdrom_device_info *cdi, int lock)
{
	uch command = (lock) ? c_lock_tray : c_unlock_tray;
	type_0_command(command, 1);	/* wait and get dsb */
	/* the logic calculates the success, 0 means successful */
	return lock ^ ((cd->dsb & dsb_tray_locked) != 0);
}

/* Although a session start should be in LBA format, we return it in 
   MSF format because it is slightly easier, and the new generic ioctl
   will take care of the necessary conversion. */
static int cm206_get_last_session(struct cdrom_device_info *cdi,
				  struct cdrom_multisession *mssp)
{
	if (!FIRST_TRACK)
		get_disc_status();
	if (mssp != NULL) {
		if (DISC_STATUS & cds_multi_session) {	/* multi-session */
			mssp->addr.msf.frame = cd->disc_status[3];
			mssp->addr.msf.second = cd->disc_status[4];
			mssp->addr.msf.minute = cd->disc_status[5];
			mssp->addr_format = CDROM_MSF;
			mssp->xa_flag = 1;
		} else {
			mssp->xa_flag = 0;
		}
		return 1;
	}
	return 0;
}

static int cm206_get_upc(struct cdrom_device_info *cdi, struct cdrom_mcn *mcn)
{
	uch upc[10];
	char *ret = mcn->medium_catalog_number;
	int i;

	if (type_1_command(c_read_upc, 10, upc))
		return -EIO;
	for (i = 0; i < 13; i++) {
		int w = i / 2 + 1, r = i % 2;
		if (r)
			ret[i] = 0x30 | (upc[w] & 0x0f);
		else
			ret[i] = 0x30 | ((upc[w] >> 4) & 0x0f);
	}
	ret[13] = '\0';
	return 0;
}

static int cm206_reset(struct cdrom_device_info *cdi)
{
	stop_read();
	reset_cm260();
	outw(dc_normal | dc_break | READ_AHEAD, r_data_control);
	mdelay(1);		/* 750 musec minimum */
	outw(dc_normal | READ_AHEAD, r_data_control);
	cd->sector_last = -1;	/* flag no data buffered */
	cd->adapter_last = -1;
	invalidate_toc();
	return 0;
}

static int cm206_select_speed(struct cdrom_device_info *cdi, int speed)
{
	int r;
	switch (speed) {
	case 0:
		r = type_0_command(c_auto_mode, 1);
		break;
	case 1:
		r = type_0_command(c_force_1x, 1);
		break;
	case 2:
		r = type_0_command(c_force_2x, 1);
		break;
	default:
		return -1;
	}
	if (r < 0)
		return r;
	else
		return 1;
}

static struct cdrom_device_ops cm206_dops = {
	.open			= cm206_open,
	.release		= cm206_release,
	.drive_status		= cm206_drive_status,
	.media_changed		= cm206_media_changed,
	.tray_move		= cm206_tray_move,
	.lock_door		= cm206_lock_door,
	.select_speed		= cm206_select_speed,
	.get_last_session	= cm206_get_last_session,
	.get_mcn		= cm206_get_upc,
	.reset			= cm206_reset,
	.audio_ioctl		= cm206_audio_ioctl,
	.capability		= CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
				  CDC_MULTI_SESSION | CDC_MEDIA_CHANGED |
				  CDC_MCN | CDC_PLAY_AUDIO | CDC_SELECT_SPEED |
				  CDC_DRIVE_STATUS,
	.n_minors		= 1,
};


static struct cdrom_device_info cm206_info = {
	.ops		= &cm206_dops,
	.speed		= 2,
	.capacity	= 1,
	.name		= "cm206",
};

static int cm206_block_open(struct inode *inode, struct file *file)
{
	return cdrom_open(&cm206_info, inode, file);
}

static int cm206_block_release(struct inode *inode, struct file *file)
{
	return cdrom_release(&cm206_info, file);
}

static int cm206_block_ioctl(struct inode *inode, struct file *file,
				unsigned cmd, unsigned long arg)
{
	switch (cmd) {
#ifdef STATISTICS
	case CM206CTL_GET_STAT:
		if (arg >= NR_STATS)
			return -EINVAL;
		return cd->stats[arg];
	case CM206CTL_GET_LAST_STAT:
		if (arg >= NR_STATS)
			return -EINVAL;
		return cd->last_stat[arg];
#endif
	default:
		break;
	}

	return cdrom_ioctl(file, &cm206_info, inode, cmd, arg);
}

static int cm206_block_media_changed(struct gendisk *disk)
{
	return cdrom_media_changed(&cm206_info);
}

static struct block_device_operations cm206_bdops =
{
	.owner		= THIS_MODULE,
	.open		= cm206_block_open,
	.release	= cm206_block_release,
	.ioctl		= cm206_block_ioctl,
	.media_changed	= cm206_block_media_changed,
};

static struct gendisk *cm206_gendisk;

/* This function probes for the adapter card. It returns the base
   address if it has found the adapter card. One can specify a base 
   port to probe specifically, or 0 which means span all possible
   bases. 

   Linus says it is too dangerous to use writes for probing, so we
   stick with pure reads for a while. Hope that 8 possible ranges,
   request_region, 15 bits of one port and 6 of another make things
   likely enough to accept the region on the first hit...
 */
static int __init probe_base_port(int base)
{
	int b = 0x300, e = 0x370;	/* this is the range of start addresses */
	volatile int fool, i;

	if (base)
		b = e = base;
	for (base = b; base <= e; base += 0x10) {
		if (!request_region(base, 0x10,"cm206"))
			continue;
		for (i = 0; i < 3; i++)
			fool = inw(base + 2);	/* empty possibly uart_receive_buffer */
		if ((inw(base + 6) & 0xffef) != 0x0001 ||	/* line_status */
		    (inw(base) & 0xad00) != 0)	{ /* data status */
		    	release_region(base,0x10);
			continue;
		}
		return (base);
	}
	return 0;
}

#if !defined(MODULE) || defined(AUTO_PROBE_MODULE)
/* Probe for irq# nr. If nr==0, probe for all possible irq's. */
static int __init probe_irq(int nr)
{
	int irqs, irq;
	outw(dc_normal | READ_AHEAD, r_data_control);	/* disable irq-generation */
	sti();
	irqs = probe_irq_on();
	reset_cm260();		/* causes interrupt */
	udelay(100);		/* wait for it */
	irq = probe_irq_off(irqs);
	outw(dc_normal | READ_AHEAD, r_data_control);	/* services interrupt */
	if (nr && irq != nr && irq > 0)
		return 0;	/* wrong interrupt happened */
	else
		return irq;
}
#endif

int __init cm206_init(void)
{
	uch e = 0;
	long int size = sizeof(struct cm206_struct);
	struct gendisk *disk;

	printk(KERN_INFO "cm206 cdrom driver " REVISION);
	cm206_base = probe_base_port(auto_probe ? 0 : cm206_base);
	if (!cm206_base) {
		printk(" can't find adapter!\n");
		return -EIO;
	}
	printk(" adapter at 0x%x", cm206_base);
	cd = (struct cm206_struct *) kmalloc(size, GFP_KERNEL);
	if (!cd)
               goto out_base;
	/* Now we have found the adaptor card, try to reset it. As we have
	 * found out earlier, this process generates an interrupt as well,
	 * so we might just exploit that fact for irq probing! */
#if !defined(MODULE) || defined(AUTO_PROBE_MODULE)
	cm206_irq = probe_irq(auto_probe ? 0 : cm206_irq);
	if (cm206_irq <= 0) {
		printk("can't find IRQ!\n");
		goto out_probe;
	} else
		printk(" IRQ %d found\n", cm206_irq);
#else
	cli();
	reset_cm260();
	/* Now, the problem here is that reset_cm260 can generate an
	   interrupt. It seems that this can cause a kernel oops some time
	   later. So we wait a while and `service' this interrupt. */
	mdelay(1);
	outw(dc_normal | READ_AHEAD, r_data_control);
	sti();
	printk(" using IRQ %d\n", cm206_irq);
#endif
	if (send_receive_polled(c_drive_configuration) !=
	    c_drive_configuration) {
		printk(KERN_INFO " drive not there\n");
		goto out_probe;
	}
	e = send_receive_polled(c_gimme);
	printk(KERN_INFO "Firmware revision %d", e & dcf_revision_code);
	if (e & dcf_transfer_rate)
		printk(" double");
	else
		printk(" single");
	printk(" speed drive");
	if (e & dcf_motorized_tray)
		printk(", motorized tray");
	if (request_irq(cm206_irq, cm206_interrupt, 0, "cm206", NULL)) {
		printk("\nUnable to reserve IRQ---aborted\n");
		goto out_probe;
	}
	printk(".\n");

	if (register_blkdev(MAJOR_NR, "cm206"))
		goto out_blkdev;

	disk = alloc_disk(1);
	if (!disk)
		goto out_disk;
	disk->major = MAJOR_NR;
	disk->first_minor = 0;
	sprintf(disk->disk_name, "cm206cd");
	disk->fops = &cm206_bdops;
	disk->flags = GENHD_FL_CD;
	cm206_gendisk = disk;
	if (register_cdrom(&cm206_info) != 0) {
		printk(KERN_INFO "Cannot register for cdrom %d!\n", MAJOR_NR);
		goto out_cdrom;
	}
	cm206_queue = blk_init_queue(do_cm206_request, &cm206_lock);
	if (!cm206_queue)
		goto out_queue;
		
	blk_queue_hardsect_size(cm206_queue, 2048);
	disk->queue = cm206_queue;
	add_disk(disk);

	memset(cd, 0, sizeof(*cd));	/* give'm some reasonable value */
	cd->sector_last = -1;	/* flag no data buffered */
	cd->adapter_last = -1;
	init_timer(&cd->timer);
	cd->timer.function = cm206_timeout;
	cd->max_sectors = (inw(r_data_status) & ds_ram_size) ? 24 : 97;
	printk(KERN_INFO "%d kB adapter memory available, "
	       " %ld bytes kernel memory used.\n", cd->max_sectors * 2,
	       size);
	return 0;

out_queue:
	unregister_cdrom(&cm206_info);
out_cdrom:
	put_disk(disk);
out_disk:
	unregister_blkdev(MAJOR_NR, "cm206");
out_blkdev:
	free_irq(cm206_irq, NULL);
out_probe:
	kfree(cd);
out_base:
	release_region(cm206_base, 16);
	return -EIO;
}

#ifdef MODULE


static void __init parse_options(void)
{
	int i;
	for (i = 0; i < 2; i++) {
		if (0x300 <= cm206[i] && i <= 0x370
		    && cm206[i] % 0x10 == 0) {
			cm206_base = cm206[i];
			auto_probe = 0;
		} else if (3 <= cm206[i] && cm206[i] <= 15) {
			cm206_irq = cm206[i];
			auto_probe = 0;
		}
	}
}

static int __cm206_init(void)
{
	parse_options();
#if !defined(AUTO_PROBE_MODULE)
	auto_probe = 0;
#endif
	return cm206_init();
}

static void __exit cm206_exit(void)
{
	del_gendisk(cm206_gendisk);
	put_disk(cm206_gendisk);
	if (unregister_cdrom(&cm206_info)) {
		printk("Can't unregister cdrom cm206\n");
		return;
	}
	if (unregister_blkdev(MAJOR_NR, "cm206")) {
		printk("Can't unregister major cm206\n");
		return;
	}
	blk_cleanup_queue(cm206_queue);
	free_irq(cm206_irq, NULL);
	kfree(cd);
	release_region(cm206_base, 16);
	printk(KERN_INFO "cm206 removed\n");
}

module_init(__cm206_init);
module_exit(cm206_exit);

#else				/* !MODULE */

/* This setup function accepts either `auto' or numbers in the range
 * 3--11 (for irq) or 0x300--0x370 (for base port) or both. */

static int __init cm206_setup(char *s)
{
	int i, p[4];

	(void) get_options(s, ARRAY_SIZE(p), p);

	if (!strcmp(s, "auto"))
		auto_probe = 1;
	for (i = 1; i <= p[0]; i++) {
		if (0x300 <= p[i] && i <= 0x370 && p[i] % 0x10 == 0) {
			cm206_base = p[i];
			auto_probe = 0;
		} else if (3 <= p[i] && p[i] <= 15) {
			cm206_irq = p[i];
			auto_probe = 0;
		}
	}
	return 1;
}

__setup("cm206=", cm206_setup);

#endif				/* !MODULE */
MODULE_ALIAS_BLOCKDEV_MAJOR(CM206_CDROM_MAJOR);

/*
 * Local variables:
 * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/include -Wall -Wstrict-prototypes -O2 -fomit-frame-pointer -pipe -fno-strength-reduce -m486 -DMODULE -DMODVERSIONS -include /usr/src/linux/include/linux/modversions.h  -c -o cm206.o cm206.c"
 * End:
 */
OpenPOWER on IntegriCloud