projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'master' into next
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / block / paride / pf.c
CommitLineData
1da177e4
LT		 1/*
2 pf.c (c) 1997-8 Grant R. Guenther <grant@torque.net>
3 Under the terms of the GNU General Public License.
4
5 This is the high-level driver for parallel port ATAPI disk
6 drives based on chips supported by the paride module.
7
8 By default, the driver will autoprobe for a single parallel
9 port ATAPI disk drive, but if their individual parameters are
10 specified, the driver can handle up to 4 drives.
11
12 The behaviour of the pf driver can be altered by setting
13 some parameters from the insmod command line. The following
14 parameters are adjustable:
15
16 drive0 These four arguments can be arrays of
17 drive1 1-7 integers as follows:
18 drive2
19 drive3 <prt>,<pro>,<uni>,<mod>,<slv>,<lun>,<dly>
20
21 Where,
22
23 <prt> is the base of the parallel port address for
24 the corresponding drive. (required)
25
26 <pro> is the protocol number for the adapter that
27 supports this drive. These numbers are
28 logged by 'paride' when the protocol modules
29 are initialised. (0 if not given)
30
31 <uni> for those adapters that support chained
32 devices, this is the unit selector for the
33 chain of devices on the given port. It should
34 be zero for devices that don't support chaining.
35 (0 if not given)
36
37 <mod> this can be -1 to choose the best mode, or one
38 of the mode numbers supported by the adapter.
39 (-1 if not given)
40
41 <slv> ATAPI CDroms can be jumpered to master or slave.
42 Set this to 0 to choose the master drive, 1 to
43 choose the slave, -1 (the default) to choose the
44 first drive found.
45
46 <lun> Some ATAPI devices support multiple LUNs.
47 One example is the ATAPI PD/CD drive from
48 Matshita/Panasonic. This device has a
49 CD drive on LUN 0 and a PD drive on LUN 1.
50 By default, the driver will search for the
51 first LUN with a supported device. Set
52 this parameter to force it to use a specific
53 LUN. (default -1)
54
55 <dly> some parallel ports require the driver to
56 go more slowly. -1 sets a default value that
57 should work with the chosen protocol. Otherwise,
58 set this to a small integer, the larger it is
59 the slower the port i/o. In some cases, setting
60 this to zero will speed up the device. (default -1)
61
62 major You may use this parameter to overide the
63 default major number (47) that this driver
64 will use. Be sure to change the device
65 name as well.
66
67 name This parameter is a character string that
68 contains the name the kernel will use for this
69 device (in /proc output, for instance).
70 (default "pf").
71
72 cluster The driver will attempt to aggregate requests
73 for adjacent blocks into larger multi-block
74 clusters. The maximum cluster size (in 512
75 byte sectors) is set with this parameter.
76 (default 64)
77
78 verbose This parameter controls the amount of logging
79 that the driver will do. Set it to 0 for
80 normal operation, 1 to see autoprobe progress
81 messages, or 2 to see additional debugging
82 output. (default 0)
83
84 nice This parameter controls the driver's use of
85 idle CPU time, at the expense of some speed.
86
87 If this driver is built into the kernel, you can use the
88 following command line parameters, with the same values
89 as the corresponding module parameters listed above:
90
91 pf.drive0
92 pf.drive1
93 pf.drive2
94 pf.drive3
95 pf.cluster
96 pf.nice
97
98 In addition, you can use the parameter pf.disable to disable
99 the driver entirely.
100
101*/
102
103/* Changes:
104
105 1.01 GRG 1998.05.03 Changes for SMP. Eliminate sti().
106 Fix for drives that don't clear STAT_ERR
107 until after next CDB delivered.
108 Small change in pf_completion to round
109 up transfer size.
110 1.02 GRG 1998.06.16 Eliminated an Ugh
111 1.03 GRG 1998.08.16 Use HZ in loop timings, extra debugging
112 1.04 GRG 1998.09.24 Added jumbo support
113
114*/
115
116#define PF_VERSION "1.04"
117#define PF_MAJOR 47
118#define PF_NAME "pf"
119#define PF_UNITS 4
120
121/* Here are things one can override from the insmod command.
122 Most are autoprobed by paride unless set here. Verbose is off
123 by default.
124
125*/
126
127static int verbose = 0;
128static int major = PF_MAJOR;
129static char *name = PF_NAME;
130static int cluster = 64;
131static int nice = 0;
132static int disable = 0;
133
134static int drive0[7] = { 0, 0, 0, -1, -1, -1, -1 };
135static int drive1[7] = { 0, 0, 0, -1, -1, -1, -1 };
136static int drive2[7] = { 0, 0, 0, -1, -1, -1, -1 };
137static int drive3[7] = { 0, 0, 0, -1, -1, -1, -1 };
138
139static int (*drives[4])[7] = {&drive0, &drive1, &drive2, &drive3};
140static int pf_drive_count;
141
142enum {D_PRT, D_PRO, D_UNI, D_MOD, D_SLV, D_LUN, D_DLY};
143
144/* end of parameters */
145
146#include <linux/module.h>
147#include <linux/init.h>
148#include <linux/fs.h>
149#include <linux/delay.h>
150#include <linux/hdreg.h>
151#include <linux/cdrom.h>
152#include <linux/spinlock.h>
153#include <linux/blkdev.h>
154#include <linux/blkpg.h>
2a48fc0a 155#include <linux/mutex.h>
1da177e4
LT		 156#include <asm/uaccess.h>
157
2a48fc0a 158static DEFINE_MUTEX(pf_mutex);
671d40f4 159static DEFINE_SPINLOCK(pf_spin_lock);
1da177e4
LT		 160
161module_param(verbose, bool, 0644);
162module_param(major, int, 0);
163module_param(name, charp, 0);
164module_param(cluster, int, 0);
165module_param(nice, int, 0);
166module_param_array(drive0, int, NULL, 0);
167module_param_array(drive1, int, NULL, 0);
168module_param_array(drive2, int, NULL, 0);
169module_param_array(drive3, int, NULL, 0);
170
171#include "paride.h"
172#include "pseudo.h"
173
174/* constants for faking geometry numbers */
175
176#define PF_FD_MAX 8192 /* use FD geometry under this size */
177#define PF_FD_HDS 2
178#define PF_FD_SPT 18
179#define PF_HD_HDS 64
180#define PF_HD_SPT 32
181
182#define PF_MAX_RETRIES 5
183#define PF_TMO 800 /* interrupt timeout in jiffies */
184#define PF_SPIN_DEL 50 /* spin delay in micro-seconds */
185
186#define PF_SPIN (1000000*PF_TMO)/(HZ*PF_SPIN_DEL)
187
188#define STAT_ERR 0x00001
189#define STAT_INDEX 0x00002
190#define STAT_ECC 0x00004
191#define STAT_DRQ 0x00008
192#define STAT_SEEK 0x00010
193#define STAT_WRERR 0x00020
194#define STAT_READY 0x00040
195#define STAT_BUSY 0x00080
196
197#define ATAPI_REQ_SENSE 0x03
198#define ATAPI_LOCK 0x1e
199#define ATAPI_DOOR 0x1b
200#define ATAPI_MODE_SENSE 0x5a
201#define ATAPI_CAPACITY 0x25
202#define ATAPI_IDENTIFY 0x12
203#define ATAPI_READ_10 0x28
204#define ATAPI_WRITE_10 0x2a
205
8cfc7ca4 206static int pf_open(struct block_device *bdev, fmode_t mode);
165125e1 207static void do_pf_request(struct request_queue * q);
8cfc7ca4 208static int pf_ioctl(struct block_device *bdev, fmode_t mode,
1da177e4 209 unsigned int cmd, unsigned long arg);
a885c8c4 210static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo);
1da177e4 211
8cfc7ca4 212static int pf_release(struct gendisk *disk, fmode_t mode);
1da177e4
LT		 213
214static int pf_detect(void);
215static void do_pf_read(void);
216static void do_pf_read_start(void);
217static void do_pf_write(void);
218static void do_pf_write_start(void);
219static void do_pf_read_drq(void);
220static void do_pf_write_done(void);
221
222#define PF_NM 0
223#define PF_RO 1
224#define PF_RW 2
225
226#define PF_NAMELEN 8
227
228struct pf_unit {
229 struct pi_adapter pia; /* interface to paride layer */
230 struct pi_adapter *pi;
231 int removable; /* removable media device ? */
232 int media_status; /* media present ? WP ? */
233 int drive; /* drive */
234 int lun;
235 int access; /* count of active opens ... */
236 int present; /* device present ? */
237 char name[PF_NAMELEN]; /* pf0, pf1, ... */
238 struct gendisk *disk;
239};
240
241static struct pf_unit units[PF_UNITS];
242
243static int pf_identify(struct pf_unit *pf);
244static void pf_lock(struct pf_unit *pf, int func);
245static void pf_eject(struct pf_unit *pf);
b1b56b93
TH		 246static unsigned int pf_check_events(struct gendisk *disk,
247 unsigned int clearing);
1da177e4
LT		 248
249static char pf_scratch[512]; /* scratch block buffer */
250
251/* the variables below are used mainly in the I/O request engine, which
252 processes only one request at a time.
253*/
254
255static int pf_retries = 0; /* i/o error retry count */
256static int pf_busy = 0; /* request being processed ? */
257static struct request *pf_req; /* current request */
258static int pf_block; /* address of next requested block */
259static int pf_count; /* number of blocks still to do */
260static int pf_run; /* sectors in current cluster */
261static int pf_cmd; /* current command READ/WRITE */
262static struct pf_unit *pf_current;/* unit of current request */
263static int pf_mask; /* stopper for pseudo-int */
264static char *pf_buf; /* buffer for request in progress */
265
266/* kernel glue structures */
267
83d5cde4 268static const struct block_device_operations pf_fops = {
1da177e4 269 .owner = THIS_MODULE,
8cfc7ca4
AV		 270 .open = pf_open,
271 .release = pf_release,
8a6cfeb6 272 .ioctl = pf_ioctl,
a885c8c4 273 .getgeo = pf_getgeo,
b1b56b93 274 .check_events = pf_check_events,
1da177e4
LT		 275};
276
277static void __init pf_init_units(void)
278{
279 struct pf_unit *pf;
280 int unit;
281
282 pf_drive_count = 0;
283 for (unit = 0, pf = units; unit < PF_UNITS; unit++, pf++) {
284 struct gendisk *disk = alloc_disk(1);
285 if (!disk)
286 continue;
287 pf->disk = disk;
288 pf->pi = &pf->pia;
289 pf->media_status = PF_NM;
290 pf->drive = (*drives[unit])[D_SLV];
291 pf->lun = (*drives[unit])[D_LUN];
292 snprintf(pf->name, PF_NAMELEN, "%s%d", name, unit);
293 disk->major = major;
294 disk->first_minor = unit;
295 strcpy(disk->disk_name, pf->name);
296 disk->fops = &pf_fops;
297 if (!(*drives[unit])[D_PRT])
298 pf_drive_count++;
299 }
300}
301
8cfc7ca4 302static int pf_open(struct block_device *bdev, fmode_t mode)
1da177e4 303{
8cfc7ca4 304 struct pf_unit *pf = bdev->bd_disk->private_data;
6e9624b8 305 int ret;
1da177e4 306
2a48fc0a 307 mutex_lock(&pf_mutex);
1da177e4
LT		 308 pf_identify(pf);
309
6e9624b8 310 ret = -ENODEV;
1da177e4 311 if (pf->media_status == PF_NM)
6e9624b8 312 goto out;
1da177e4 313
6e9624b8 314 ret = -EROFS;
8cfc7ca4 315 if ((pf->media_status == PF_RO) && (mode & FMODE_WRITE))
6e9624b8 316 goto out;
1da177e4 317
6e9624b8 318 ret = 0;
1da177e4
LT		 319 pf->access++;
320 if (pf->removable)
321 pf_lock(pf, 1);
6e9624b8 322out:
2a48fc0a 323 mutex_unlock(&pf_mutex);
6e9624b8 324 return ret;
1da177e4
LT		 325}
326
a885c8c4 327static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1da177e4 328{
a885c8c4
CH		 329 struct pf_unit *pf = bdev->bd_disk->private_data;
330 sector_t capacity = get_capacity(pf->disk);
331
1da177e4 332 if (capacity < PF_FD_MAX) {
a885c8c4
CH		 333 geo->cylinders = sector_div(capacity, PF_FD_HDS * PF_FD_SPT);
334 geo->heads = PF_FD_HDS;
335 geo->sectors = PF_FD_SPT;
1da177e4 336 } else {
a885c8c4
CH		 337 geo->cylinders = sector_div(capacity, PF_HD_HDS * PF_HD_SPT);
338 geo->heads = PF_HD_HDS;
339 geo->sectors = PF_HD_SPT;
1da177e4 340 }
a885c8c4
CH		 341
342 return 0;
343}
344
8cfc7ca4 345static int pf_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg)
a885c8c4 346{
8cfc7ca4 347 struct pf_unit *pf = bdev->bd_disk->private_data;
a885c8c4
CH		 348
349 if (cmd != CDROMEJECT)
350 return -EINVAL;
351
352 if (pf->access != 1)
353 return -EBUSY;
2a48fc0a 354 mutex_lock(&pf_mutex);
a885c8c4 355 pf_eject(pf);
2a48fc0a 356 mutex_unlock(&pf_mutex);
8a6cfeb6 357
1da177e4
LT		 358 return 0;
359}
360
8cfc7ca4 361static int pf_release(struct gendisk *disk, fmode_t mode)
1da177e4 362{
8cfc7ca4 363 struct pf_unit *pf = disk->private_data;
1da177e4 364
2a48fc0a 365 mutex_lock(&pf_mutex);
6e9624b8 366 if (pf->access <= 0) {
2a48fc0a 367 mutex_unlock(&pf_mutex);
1da177e4 368 return -EINVAL;
6e9624b8 369 }
1da177e4
LT		 370
371 pf->access--;
372
373 if (!pf->access && pf->removable)
374 pf_lock(pf, 0);
375
2a48fc0a 376 mutex_unlock(&pf_mutex);
1da177e4
LT		 377 return 0;
378
379}
380
b1b56b93 381static unsigned int pf_check_events(struct gendisk *disk, unsigned int clearing)
1da177e4 382{
b1b56b93 383 return DISK_EVENT_MEDIA_CHANGE;
1da177e4
LT		 384}
385
386static inline int status_reg(struct pf_unit *pf)
387{
388 return pi_read_regr(pf->pi, 1, 6);
389}
390
391static inline int read_reg(struct pf_unit *pf, int reg)
392{
393 return pi_read_regr(pf->pi, 0, reg);
394}
395
396static inline void write_reg(struct pf_unit *pf, int reg, int val)
397{
398 pi_write_regr(pf->pi, 0, reg, val);
399}
400
401static int pf_wait(struct pf_unit *pf, int go, int stop, char *fun, char *msg)
402{
403 int j, r, e, s, p;
404
405 j = 0;
406 while ((((r = status_reg(pf)) & go) || (stop && (!(r & stop))))
407 && (j++ < PF_SPIN))
408 udelay(PF_SPIN_DEL);
409
c12ec0a2 410 if ((r & (STAT_ERR & stop)) || (j > PF_SPIN)) {
1da177e4
LT		 411 s = read_reg(pf, 7);
412 e = read_reg(pf, 1);
413 p = read_reg(pf, 2);
c12ec0a2 414 if (j > PF_SPIN)
1da177e4
LT		 415 e |= 0x100;
416 if (fun)
417 printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
418 " loop=%d phase=%d\n",
419 pf->name, fun, msg, r, s, e, j, p);
420 return (e << 8) + s;
421 }
422 return 0;
423}
424
425static int pf_command(struct pf_unit *pf, char *cmd, int dlen, char *fun)
426{
427 pi_connect(pf->pi);
428
429 write_reg(pf, 6, 0xa0+0x10*pf->drive);
430
431 if (pf_wait(pf, STAT_BUSY | STAT_DRQ, 0, fun, "before command")) {
432 pi_disconnect(pf->pi);
433 return -1;
434 }
435
436 write_reg(pf, 4, dlen % 256);
437 write_reg(pf, 5, dlen / 256);
438 write_reg(pf, 7, 0xa0); /* ATAPI packet command */
439
440 if (pf_wait(pf, STAT_BUSY, STAT_DRQ, fun, "command DRQ")) {
441 pi_disconnect(pf->pi);
442 return -1;
443 }
444
445 if (read_reg(pf, 2) != 1) {
446 printk("%s: %s: command phase error\n", pf->name, fun);
447 pi_disconnect(pf->pi);
448 return -1;
449 }
450
451 pi_write_block(pf->pi, cmd, 12);
452
453 return 0;
454}
455
456static int pf_completion(struct pf_unit *pf, char *buf, char *fun)
457{
458 int r, s, n;
459
460 r = pf_wait(pf, STAT_BUSY, STAT_DRQ | STAT_READY | STAT_ERR,
461 fun, "completion");
462
463 if ((read_reg(pf, 2) & 2) && (read_reg(pf, 7) & STAT_DRQ)) {
464 n = (((read_reg(pf, 4) + 256 * read_reg(pf, 5)) +
465 3) & 0xfffc);
466 pi_read_block(pf->pi, buf, n);
467 }
468
469 s = pf_wait(pf, STAT_BUSY, STAT_READY | STAT_ERR, fun, "data done");
470
471 pi_disconnect(pf->pi);
472
473 return (r ? r : s);
474}
475
476static void pf_req_sense(struct pf_unit *pf, int quiet)
477{
478 char rs_cmd[12] =
479 { ATAPI_REQ_SENSE, pf->lun << 5, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
480 char buf[16];
481 int r;
482
483 r = pf_command(pf, rs_cmd, 16, "Request sense");
484 mdelay(1);
485 if (!r)
486 pf_completion(pf, buf, "Request sense");
487
488 if ((!r) && (!quiet))
489 printk("%s: Sense key: %x, ASC: %x, ASQ: %x\n",
490 pf->name, buf[2] & 0xf, buf[12], buf[13]);
491}
492
493static int pf_atapi(struct pf_unit *pf, char *cmd, int dlen, char *buf, char *fun)
494{
495 int r;
496
497 r = pf_command(pf, cmd, dlen, fun);
498 mdelay(1);
499 if (!r)
500 r = pf_completion(pf, buf, fun);
501 if (r)
502 pf_req_sense(pf, !fun);
503
504 return r;
505}
506
1da177e4
LT		 507static void pf_lock(struct pf_unit *pf, int func)
508{
509 char lo_cmd[12] = { ATAPI_LOCK, pf->lun << 5, 0, 0, func, 0, 0, 0, 0, 0, 0, 0 };
510
e62aa046 511 pf_atapi(pf, lo_cmd, 0, pf_scratch, func ? "lock" : "unlock");
1da177e4
LT		 512}
513
514static void pf_eject(struct pf_unit *pf)
515{
516 char ej_cmd[12] = { ATAPI_DOOR, pf->lun << 5, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0 };
517
518 pf_lock(pf, 0);
519 pf_atapi(pf, ej_cmd, 0, pf_scratch, "eject");
520}
521
522#define PF_RESET_TMO 30 /* in tenths of a second */
523
524static void pf_sleep(int cs)
525{
86e84862 526 schedule_timeout_interruptible(cs);
1da177e4
LT		 527}
528
529/* the ATAPI standard actually specifies the contents of all 7 registers
530 after a reset, but the specification is ambiguous concerning the last
531 two bytes, and different drives interpret the standard differently.
532 */
533
534static int pf_reset(struct pf_unit *pf)
535{
536 int i, k, flg;
537 int expect[5] = { 1, 1, 1, 0x14, 0xeb };
538
539 pi_connect(pf->pi);
540 write_reg(pf, 6, 0xa0+0x10*pf->drive);
541 write_reg(pf, 7, 8);
542
543 pf_sleep(20 * HZ / 1000);
544
545 k = 0;
546 while ((k++ < PF_RESET_TMO) && (status_reg(pf) & STAT_BUSY))
547 pf_sleep(HZ / 10);
548
549 flg = 1;
550 for (i = 0; i < 5; i++)
551 flg &= (read_reg(pf, i + 1) == expect[i]);
552
553 if (verbose) {
554 printk("%s: Reset (%d) signature = ", pf->name, k);
555 for (i = 0; i < 5; i++)
556 printk("%3x", read_reg(pf, i + 1));
557 if (!flg)
558 printk(" (incorrect)");
559 printk("\n");
560 }
561
562 pi_disconnect(pf->pi);
563 return flg - 1;
564}
565
566static void pf_mode_sense(struct pf_unit *pf)
567{
568 char ms_cmd[12] =
569 { ATAPI_MODE_SENSE, pf->lun << 5, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0 };
570 char buf[8];
571
e62aa046 572 pf_atapi(pf, ms_cmd, 8, buf, "mode sense");
1da177e4
LT		 573 pf->media_status = PF_RW;
574 if (buf[3] & 0x80)
575 pf->media_status = PF_RO;
576}
577
578static void xs(char *buf, char *targ, int offs, int len)
579{
580 int j, k, l;
581
582 j = 0;
583 l = 0;
584 for (k = 0; k < len; k++)
585 if ((buf[k + offs] != 0x20) || (buf[k + offs] != l))
586 l = targ[j++] = buf[k + offs];
587 if (l == 0x20)
588 j--;
589 targ[j] = 0;
590}
591
592static int xl(char *buf, int offs)
593{
594 int v, k;
595
596 v = 0;
597 for (k = 0; k < 4; k++)
598 v = v * 256 + (buf[k + offs] & 0xff);
599 return v;
600}
601
602static void pf_get_capacity(struct pf_unit *pf)
603{
604 char rc_cmd[12] = { ATAPI_CAPACITY, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
605 char buf[8];
606 int bs;
607
e62aa046 608 if (pf_atapi(pf, rc_cmd, 8, buf, "get capacity")) {
1da177e4
LT		 609 pf->media_status = PF_NM;
610 return;
611 }
612 set_capacity(pf->disk, xl(buf, 0) + 1);
613 bs = xl(buf, 4);
614 if (bs != 512) {
615 set_capacity(pf->disk, 0);
616 if (verbose)
617 printk("%s: Drive %d, LUN %d,"
618 " unsupported block size %d\n",
619 pf->name, pf->drive, pf->lun, bs);
620 }
621}
622
623static int pf_identify(struct pf_unit *pf)
624{
625 int dt, s;
626 char *ms[2] = { "master", "slave" };
627 char mf[10], id[18];
628 char id_cmd[12] =
629 { ATAPI_IDENTIFY, pf->lun << 5, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
630 char buf[36];
631
632 s = pf_atapi(pf, id_cmd, 36, buf, "identify");
633 if (s)
634 return -1;
635
636 dt = buf[0] & 0x1f;
637 if ((dt != 0) && (dt != 7)) {
638 if (verbose)
639 printk("%s: Drive %d, LUN %d, unsupported type %d\n",
640 pf->name, pf->drive, pf->lun, dt);
641 return -1;
642 }
643
644 xs(buf, mf, 8, 8);
645 xs(buf, id, 16, 16);
646
647 pf->removable = (buf[1] & 0x80);
648
649 pf_mode_sense(pf);
650 pf_mode_sense(pf);
651 pf_mode_sense(pf);
652
653 pf_get_capacity(pf);
654
655 printk("%s: %s %s, %s LUN %d, type %d",
656 pf->name, mf, id, ms[pf->drive], pf->lun, dt);
657 if (pf->removable)
658 printk(", removable");
659 if (pf->media_status == PF_NM)
660 printk(", no media\n");
661 else {
662 if (pf->media_status == PF_RO)
663 printk(", RO");
664 printk(", %llu blocks\n",
665 (unsigned long long)get_capacity(pf->disk));
666 }
667 return 0;
668}
669
670/* returns 0, with id set if drive is detected
671 -1, if drive detection failed
672*/
673static int pf_probe(struct pf_unit *pf)
674{
675 if (pf->drive == -1) {
676 for (pf->drive = 0; pf->drive <= 1; pf->drive++)
677 if (!pf_reset(pf)) {
678 if (pf->lun != -1)
679 return pf_identify(pf);
680 else
681 for (pf->lun = 0; pf->lun < 8; pf->lun++)
682 if (!pf_identify(pf))
683 return 0;
684 }
685 } else {
686 if (pf_reset(pf))
687 return -1;
688 if (pf->lun != -1)
689 return pf_identify(pf);
690 for (pf->lun = 0; pf->lun < 8; pf->lun++)
691 if (!pf_identify(pf))
692 return 0;
693 }
694 return -1;
695}
696
697static int pf_detect(void)
698{
699 struct pf_unit *pf = units;
700 int k, unit;
701
702 printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
703 name, name, PF_VERSION, major, cluster, nice);
704
705 k = 0;
706 if (pf_drive_count == 0) {
707 if (pi_init(pf->pi, 1, -1, -1, -1, -1, -1, pf_scratch, PI_PF,
708 verbose, pf->name)) {
709 if (!pf_probe(pf) && pf->disk) {
710 pf->present = 1;
711 k++;
712 } else
713 pi_release(pf->pi);
714 }
715
716 } else
717 for (unit = 0; unit < PF_UNITS; unit++, pf++) {
718 int *conf = *drives[unit];
719 if (!conf[D_PRT])
720 continue;
721 if (pi_init(pf->pi, 0, conf[D_PRT], conf[D_MOD],
722 conf[D_UNI], conf[D_PRO], conf[D_DLY],
723 pf_scratch, PI_PF, verbose, pf->name)) {
8e53cfc8 724 if (pf->disk && !pf_probe(pf)) {
1da177e4
LT		 725 pf->present = 1;
726 k++;
727 } else
728 pi_release(pf->pi);
729 }
730 }
731 if (k)
732 return 0;
733
734 printk("%s: No ATAPI disk detected\n", name);
735 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
736 put_disk(pf->disk);
737 return -1;
738}
739
740/* The i/o request engine */
741
742static int pf_start(struct pf_unit *pf, int cmd, int b, int c)
743{
744 int i;
745 char io_cmd[12] = { cmd, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
746
747 for (i = 0; i < 4; i++) {
748 io_cmd[5 - i] = b & 0xff;
749 b = b >> 8;
750 }
751
752 io_cmd[8] = c & 0xff;
753 io_cmd[7] = (c >> 8) & 0xff;
754
755 i = pf_command(pf, io_cmd, c * 512, "start i/o");
756
757 mdelay(1);
758
759 return i;
760}
761
762static int pf_ready(void)
763{
764 return (((status_reg(pf_current) & (STAT_BUSY | pf_mask)) == pf_mask));
765}
766
767static struct request_queue *pf_queue;
768
f06d9a2b 769static void pf_end_request(int err)
9564df1f 770{
b12d4f82 771 if (pf_req && !__blk_end_request_cur(pf_req, err))
9564df1f 772 pf_req = NULL;
9564df1f
JA		 773}
774
165125e1 775static void do_pf_request(struct request_queue * q)
1da177e4
LT		 776{
777 if (pf_busy)
778 return;
779repeat:
b12d4f82 780 if (!pf_req) {
9934c8c0 781 pf_req = blk_fetch_request(q);
b12d4f82
TH		 782 if (!pf_req)
783 return;
b12d4f82 784 }
1da177e4
LT		 785
786 pf_current = pf_req->rq_disk->private_data;
83096ebf
TH		 787 pf_block = blk_rq_pos(pf_req);
788 pf_run = blk_rq_sectors(pf_req);
789 pf_count = blk_rq_cur_sectors(pf_req);
1da177e4
LT		 790
791 if (pf_block + pf_count > get_capacity(pf_req->rq_disk)) {
f06d9a2b 792 pf_end_request(-EIO);
1da177e4
LT		 793 goto repeat;
794 }
795
796 pf_cmd = rq_data_dir(pf_req);
797 pf_buf = pf_req->buffer;
798 pf_retries = 0;
799
800 pf_busy = 1;
801 if (pf_cmd == READ)
802 pi_do_claimed(pf_current->pi, do_pf_read);
803 else if (pf_cmd == WRITE)
804 pi_do_claimed(pf_current->pi, do_pf_write);
805 else {
806 pf_busy = 0;
f06d9a2b 807 pf_end_request(-EIO);
1da177e4
LT		 808 goto repeat;
809 }
810}
811
812static int pf_next_buf(void)
813{
814 unsigned long saved_flags;
815
816 pf_count--;
817 pf_run--;
818 pf_buf += 512;
819 pf_block++;
820 if (!pf_run)
1da177e4 821 return 1;
e62aa046
OZ		 822 if (!pf_count) {
823 spin_lock_irqsave(&pf_spin_lock, saved_flags);
f06d9a2b 824 pf_end_request(0);
e62aa046
OZ		 825 spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
826 if (!pf_req)
827 return 1;
83096ebf 828 pf_count = blk_rq_cur_sectors(pf_req);
e62aa046
OZ		 829 pf_buf = pf_req->buffer;
830 }
831 return 0;
1da177e4
LT		 832}
833
f06d9a2b 834static inline void next_request(int err)
1da177e4
LT		 835{
836 unsigned long saved_flags;
837
838 spin_lock_irqsave(&pf_spin_lock, saved_flags);
f06d9a2b 839 pf_end_request(err);
1da177e4
LT		 840 pf_busy = 0;
841 do_pf_request(pf_queue);
842 spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
843}
844
845/* detach from the calling context - in case the spinlock is held */
846static void do_pf_read(void)
847{
848 ps_set_intr(do_pf_read_start, NULL, 0, nice);
849}
850
851static void do_pf_read_start(void)
852{
853 pf_busy = 1;
854
855 if (pf_start(pf_current, ATAPI_READ_10, pf_block, pf_run)) {
856 pi_disconnect(pf_current->pi);
857 if (pf_retries < PF_MAX_RETRIES) {
858 pf_retries++;
859 pi_do_claimed(pf_current->pi, do_pf_read_start);
860 return;
861 }
f06d9a2b 862 next_request(-EIO);
1da177e4
LT		 863 return;
864 }
865 pf_mask = STAT_DRQ;
866 ps_set_intr(do_pf_read_drq, pf_ready, PF_TMO, nice);
867}
868
869static void do_pf_read_drq(void)
870{
871 while (1) {
872 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
873 "read block", "completion") & STAT_ERR) {
874 pi_disconnect(pf_current->pi);
875 if (pf_retries < PF_MAX_RETRIES) {
876 pf_req_sense(pf_current, 0);
877 pf_retries++;
878 pi_do_claimed(pf_current->pi, do_pf_read_start);
879 return;
880 }
f06d9a2b 881 next_request(-EIO);
1da177e4
LT		 882 return;
883 }
884 pi_read_block(pf_current->pi, pf_buf, 512);
885 if (pf_next_buf())
886 break;
887 }
888 pi_disconnect(pf_current->pi);
f06d9a2b 889 next_request(0);
1da177e4
LT		 890}
891
892static void do_pf_write(void)
893{
894 ps_set_intr(do_pf_write_start, NULL, 0, nice);
895}
896
897static void do_pf_write_start(void)
898{
899 pf_busy = 1;
900
901 if (pf_start(pf_current, ATAPI_WRITE_10, pf_block, pf_run)) {
902 pi_disconnect(pf_current->pi);
903 if (pf_retries < PF_MAX_RETRIES) {
904 pf_retries++;
905 pi_do_claimed(pf_current->pi, do_pf_write_start);
906 return;
907 }
f06d9a2b 908 next_request(-EIO);
1da177e4
LT		 909 return;
910 }
911
912 while (1) {
913 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
914 "write block", "data wait") & STAT_ERR) {
915 pi_disconnect(pf_current->pi);
916 if (pf_retries < PF_MAX_RETRIES) {
917 pf_retries++;
918 pi_do_claimed(pf_current->pi, do_pf_write_start);
919 return;
920 }
f06d9a2b 921 next_request(-EIO);
1da177e4
LT		 922 return;
923 }
924 pi_write_block(pf_current->pi, pf_buf, 512);
925 if (pf_next_buf())
926 break;
927 }
928 pf_mask = 0;
929 ps_set_intr(do_pf_write_done, pf_ready, PF_TMO, nice);
930}
931
932static void do_pf_write_done(void)
933{
934 if (pf_wait(pf_current, STAT_BUSY, 0, "write block", "done") & STAT_ERR) {
935 pi_disconnect(pf_current->pi);
936 if (pf_retries < PF_MAX_RETRIES) {
937 pf_retries++;
938 pi_do_claimed(pf_current->pi, do_pf_write_start);
939 return;
940 }
f06d9a2b 941 next_request(-EIO);
1da177e4
LT		 942 return;
943 }
944 pi_disconnect(pf_current->pi);
f06d9a2b 945 next_request(0);
1da177e4
LT		 946}
947
948static int __init pf_init(void)
949{ /* preliminary initialisation */
950 struct pf_unit *pf;
951 int unit;
952
953 if (disable)
8bca98ca 954 return -EINVAL;
1da177e4
LT		 955
956 pf_init_units();
957
958 if (pf_detect())
8bca98ca 959 return -ENODEV;
1da177e4
LT		 960 pf_busy = 0;
961
962 if (register_blkdev(major, name)) {
963 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
964 put_disk(pf->disk);
8bca98ca 965 return -EBUSY;
1da177e4
LT		 966 }
967 pf_queue = blk_init_queue(do_pf_request, &pf_spin_lock);
968 if (!pf_queue) {
969 unregister_blkdev(major, name);
970 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
971 put_disk(pf->disk);
8bca98ca 972 return -ENOMEM;
1da177e4
LT		 973 }
974
8a78362c 975 blk_queue_max_segments(pf_queue, cluster);
1da177e4
LT		 976
977 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
978 struct gendisk *disk = pf->disk;
979
980 if (!pf->present)
981 continue;
982 disk->private_data = pf;
983 disk->queue = pf_queue;
984 add_disk(disk);
985 }
986 return 0;
987}
988
989static void __exit pf_exit(void)
990{
991 struct pf_unit *pf;
992 int unit;
993 unregister_blkdev(major, name);
994 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
995 if (!pf->present)
996 continue;
997 del_gendisk(pf->disk);
998 put_disk(pf->disk);
999 pi_release(pf->pi);
1000 }
1001 blk_cleanup_queue(pf_queue);
1002}
1003
1004MODULE_LICENSE("GPL");
1005module_init(pf_init)
1006module_exit(pf_exit)
kernel source for telekom puls (alcatel/mediatek)