]> git.pld-linux.org Git - packages/kernel.git/blame - patch-2.6.0-test11-bart1
projects / packages / kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- moving config-* fixed.
[packages/kernel.git] / patch-2.6.0-test11-bart1
CommitLineData
14ccec22 1diff -uNr -X exclude linux-2.6.0-test11/arch/i386/kernel/mpparse.c linux/arch/i386/kernel/mpparse.c
2--- linux-2.6.0-test11/arch/i386/kernel/mpparse.c 2003-12-08 00:29:12.000000000 +0100
3+++ linux/arch/i386/kernel/mpparse.c 2003-12-08 00:33:52.671960352 +0100
4@@ -962,7 +962,8 @@
5 */
6 for (i = 0; i < mp_irq_entries; i++) {
7 if ((mp_irqs[i].mpc_dstapic == intsrc.mpc_dstapic)
8- && (mp_irqs[i].mpc_srcbusirq == intsrc.mpc_srcbusirq)) {
9+ && (mp_irqs[i].mpc_srcbusirq == intsrc.mpc_srcbusirq)
10+ && (mp_irqs[i].mpc_irqtype == intsrc.mpc_irqtype)) {
11 mp_irqs[i] = intsrc;
12 found = 1;
13 break;
14diff -uNr -X exclude linux-2.6.0-test11/arch/i386/pci/fixup.c linux/arch/i386/pci/fixup.c
15--- linux-2.6.0-test11/arch/i386/pci/fixup.c 2003-12-08 00:29:12.000000000 +0100
16+++ linux/arch/i386/pci/fixup.c 2003-12-08 00:33:52.521983152 +0100
17@@ -187,6 +187,22 @@
18 dev->transparent = 1;
19 }
20
21+/*
22+ * Halt Disconnect and Stop Grant Disconnect (bit 4 at offset 0x6F)
23+ * must be disabled when APIC is used (or lockups will happen).
24+ */
25+static void __devinit pci_fixup_nforce2_disconnect(struct pci_dev *d)
26+{
27+ u8 t;
28+
29+ pci_read_config_byte(d, 0x6F, &t);
30+ if (t & 0x10) {
31+ printk(KERN_INFO "PCI: disabling nForce2 Halt Disconnect"
32+ " and Stop Grant Disconnect\n");
33+ pci_write_config_byte(d, 0x6F, (t & 0xef));
34+ }
35+}
36+
37 struct pci_fixup pcibios_fixups[] = {
38 { PCI_FIXUP_HEADER, PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82451NX, pci_fixup_i450nx },
39 { PCI_FIXUP_HEADER, PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82454GX, pci_fixup_i450gx },
40@@ -205,5 +221,6 @@
41 { PCI_FIXUP_HEADER, PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8367_0, pci_fixup_via_northbridge_bug },
42 { PCI_FIXUP_HEADER, PCI_VENDOR_ID_NCR, PCI_DEVICE_ID_NCR_53C810, pci_fixup_ncr53c810 },
43 { PCI_FIXUP_HEADER, PCI_VENDOR_ID_INTEL, PCI_ANY_ID, pci_fixup_transparent_bridge },
44+ { PCI_FIXUP_HEADER, PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE2, pci_fixup_nforce2_disconnect },
45 { 0 }
46 };
47diff -uNr -X exclude linux-2.6.0-test11/drivers/block/ll_rw_blk.c linux/drivers/block/ll_rw_blk.c
48--- linux-2.6.0-test11/drivers/block/ll_rw_blk.c 2003-12-08 00:29:13.000000000 +0100
49+++ linux/drivers/block/ll_rw_blk.c 2003-12-08 00:33:51.201183944 +0100
50@@ -780,11 +780,6 @@
51 "REQ_PM_SUSPEND",
52 "REQ_PM_RESUME",
53 "REQ_PM_SHUTDOWN",
54- "REQ_IDETAPE_PC1",
55- "REQ_IDETAPE_PC2",
56- "REQ_IDETAPE_READ",
57- "REQ_IDETAPE_WRITE",
58- "REQ_IDETAPE_READ_BUFFER",
59 };
60
61 void blk_dump_rq_flags(struct request *rq, char *msg)
62diff -uNr -X exclude linux-2.6.0-test11/drivers/ide/ide-io.c linux/drivers/ide/ide-io.c
63--- linux-2.6.0-test11/drivers/ide/ide-io.c 2003-12-08 00:29:12.000000000 +0100
64+++ linux/drivers/ide/ide-io.c 2003-12-08 00:33:52.834935576 +0100
65@@ -54,37 +54,6 @@
66 #include <asm/io.h>
67 #include <asm/bitops.h>
68
69-#if (DISK_RECOVERY_TIME > 0)
70-
71-#error So the User Has To Fix the Compilation And Stop Hacking Port 0x43. Does anyone ever use this anyway ??
72-
73-/*
74- * For really screwy hardware (hey, at least it *can* be used with Linux)
75- * we can enforce a minimum delay time between successive operations.
76- */
77-static unsigned long read_timer (ide_hwif_t *hwif)
78-{
79- unsigned long t, flags;
80- int i;
81-
82- /* FIXME this is completely unsafe! */
83- local_irq_save(flags);
84- t = jiffies * 11932;
85- outb_p(0, 0x43);
86- i = inb_p(0x40);
87- i |= inb_p(0x40) << 8;
88- local_irq_restore(flags);
89- return (t - i);
90-}
91-#endif /* DISK_RECOVERY_TIME */
92-
93-static inline void set_recovery_timer (ide_hwif_t *hwif)
94-{
95-#if (DISK_RECOVERY_TIME > 0)
96- hwif->last_time = read_timer(hwif);
97-#endif /* DISK_RECOVERY_TIME */
98-}
99-
100 /**
101 * ide_end_request - complete an IDE I/O
102 * @drive: IDE device for the I/O
103@@ -653,10 +622,6 @@
104 if (block == 0 && drive->remap_0_to_1 == 1)
105 block = 1; /* redirect MBR access to EZ-Drive partn table */
106
107-#if (DISK_RECOVERY_TIME > 0)
108- while ((read_timer() - HWIF(drive)->last_time) < DISK_RECOVERY_TIME);
109-#endif
110-
111 if (blk_pm_suspend_request(rq) &&
112 rq->pm->pm_step == ide_pm_state_start_suspend)
113 /* Mark drive blocked when starting the suspend sequence. */
114@@ -1116,7 +1081,6 @@
115 startstop =
116 DRIVER(drive)->error(drive, "irq timeout", hwif->INB(IDE_STATUS_REG));
117 }
118- set_recovery_timer(hwif);
119 drive->service_time = jiffies - drive->service_start;
120 spin_lock_irq(&ide_lock);
121 enable_irq(hwif->irq);
122@@ -1313,7 +1277,6 @@
123 * same irq as is currently being serviced here, and Linux
124 * won't allow another of the same (on any CPU) until we return.
125 */
126- set_recovery_timer(HWIF(drive));
127 drive->service_time = jiffies - drive->service_start;
128 if (startstop == ide_stopped) {
129 if (hwgroup->handler == NULL) { /* paranoia */
130diff -uNr -X exclude linux-2.6.0-test11/drivers/ide/ide-tape.c linux/drivers/ide/ide-tape.c
131--- linux-2.6.0-test11/drivers/ide/ide-tape.c 2003-12-08 00:29:13.000000000 +0100
132+++ linux/drivers/ide/ide-tape.c 2003-12-08 00:33:51.207183032 +0100
133@@ -1,5 +1,5 @@
134 /*
135- * linux/drivers/ide/ide-tape.c Version 1.17b Oct, 2002
136+ * linux/drivers/ide/ide-tape.c Version 1.19 Nov, 2003
137 *
138 * Copyright (C) 1995 - 1999 Gadi Oxman <gadio@netvision.net.il>
139 *
140@@ -422,7 +422,7 @@
141 * sharing a (fast) ATA-2 disk with any (slow) new ATAPI device.
142 */
143
144-#define IDETAPE_VERSION "1.17b-ac1"
145+#define IDETAPE_VERSION "1.19"
146
147 #include <linux/config.h>
148 #include <linux/module.h>
149@@ -450,9 +450,6 @@
150 #include <asm/unaligned.h>
151 #include <asm/bitops.h>
152
153-
154-#define NO_LONGER_REQUIRED (1)
155-
156 /*
157 * OnStream support
158 */
159@@ -652,9 +649,11 @@
160 #define IDETAPE_PC_STACK (10 + IDETAPE_MAX_PC_RETRIES)
161
162 /*
163- * Some tape drives require a long irq timeout
164+ * Some drives (for example, Seagate STT3401A Travan) require a very long
165+ * timeout, because they don't return an interrupt or clear their busy bit
166+ * until after the command completes (even retension commands).
167 */
168-#define IDETAPE_WAIT_CMD (60*HZ)
169+#define IDETAPE_WAIT_CMD (900*HZ)
170
171 /*
172 * The following parameter is used to select the point in the internal
173@@ -1032,6 +1031,10 @@
174
175 /* the door is currently locked */
176 int door_locked;
177+ /* the tape hardware is write protected */
178+ char drv_write_prot;
179+ /* the tape is write protected (hardware or opened as read-only) */
180+ char write_prot;
181
182 /*
183 * OnStream flags
184@@ -1164,6 +1167,8 @@
185 #define IDETAPE_DRQ_INTERRUPT 6 /* DRQ interrupt device */
186 #define IDETAPE_READ_ERROR 7
187 #define IDETAPE_PIPELINE_ACTIVE 8 /* pipeline active */
188+/* 0 = no tape is loaded, so we don't rewind after ejecting */
189+#define IDETAPE_MEDIUM_PRESENT 9
190
191 /*
192 * Supported ATAPI tape drives packet commands
193@@ -1211,10 +1216,14 @@
194 * requests to the tail of our block device request queue and wait
195 * for their completion.
196 */
197-#define idetape_request(rq) \
198- ((rq)->flags & (REQ_IDETAPE_PC1 | REQ_IDETAPE_PC2 | \
199- REQ_IDETAPE_READ | REQ_IDETAPE_WRITE | \
200- REQ_IDETAPE_READ_BUFFER))
201+
202+enum {
203+ REQ_IDETAPE_PC1 = (1 << 0), /* packet command (first stage) */
204+ REQ_IDETAPE_PC2 = (1 << 1), /* packet command (second stage) */
205+ REQ_IDETAPE_READ = (1 << 2),
206+ REQ_IDETAPE_WRITE = (1 << 3),
207+ REQ_IDETAPE_READ_BUFFER = (1 << 4),
208+};
209
210 /*
211 * Error codes which are returned in rq->errors to the higher part
212@@ -1665,6 +1674,20 @@
213 idetape_update_buffers(pc);
214 }
215
216+ /*
217+ * If error was the result of a zero-length read or write command,
218+ * with sense key=5, asc=0x22, ascq=0, let it slide. Some drives
219+ * (i.e. Seagate STT3401A Travan) don't support 0-length read/writes.
220+ */
221+ if ((pc->c[0] == IDETAPE_READ_CMD || pc->c[0] == IDETAPE_WRITE_CMD)
222+ && pc->c[4] == 0 && pc->c[3] == 0 && pc->c[2] == 0) { /* length==0 */
223+ if (result->sense_key == 5) {
224+ /* don't report an error, everything's ok */
225+ pc->error = 0;
226+ /* don't retry read/write */
227+ set_bit(PC_ABORT, &pc->flags);
228+ }
229+ }
230 if (pc->c[0] == IDETAPE_READ_CMD && result->filemark) {
231 pc->error = IDETAPE_ERROR_FILEMARK;
232 set_bit(PC_ABORT, &pc->flags);
233@@ -1805,10 +1828,15 @@
234 }
235 }
236
237-static void idetape_abort_pipeline (ide_drive_t *drive, idetape_stage_t *last_stage)
238+/*
239+ * This will free all the pipeline stages starting from new_last_stage->next
240+ * to the end of the list, and point tape->last_stage to new_last_stage.
241+ */
242+static void idetape_abort_pipeline(ide_drive_t *drive,
243+ idetape_stage_t *new_last_stage)
244 {
245 idetape_tape_t *tape = drive->driver_data;
246- idetape_stage_t *stage = tape->next_stage;
247+ idetape_stage_t *stage = new_last_stage->next;
248 idetape_stage_t *nstage;
249
250 #if IDETAPE_DEBUG_LOG
251@@ -1822,9 +1850,9 @@
252 --tape->nr_pending_stages;
253 stage = nstage;
254 }
255- tape->last_stage = last_stage;
256- if (last_stage)
257- last_stage->next = NULL;
258+ if (new_last_stage)
259+ new_last_stage->next = NULL;
260+ tape->last_stage = new_last_stage;
261 tape->next_stage = NULL;
262 }
263
264@@ -1868,7 +1896,7 @@
265 tape->active_stage = NULL;
266 tape->active_data_request = NULL;
267 tape->nr_pending_stages--;
268- if (rq->flags & REQ_IDETAPE_WRITE) {
269+ if (rq->cmd[0] & REQ_IDETAPE_WRITE) {
270 #if ONSTREAM_DEBUG
271 if (tape->debug_level >= 2) {
272 if (tape->onstream) {
273@@ -1914,7 +1942,7 @@
274 }
275 }
276 }
277- } else if (rq->flags & REQ_IDETAPE_READ) {
278+ } else if (rq->cmd[0] & REQ_IDETAPE_READ) {
279 if (error == IDETAPE_ERROR_EOD) {
280 set_bit(IDETAPE_PIPELINE_ERROR, &tape->flags);
281 idetape_abort_pipeline(drive, active_stage);
282@@ -1972,6 +2000,13 @@
283 pc->callback = &idetape_request_sense_callback;
284 }
285
286+static void idetape_init_rq(struct request *rq, u8 cmd)
287+{
288+ memset(rq, 0, sizeof(*rq));
289+ rq->flags = REQ_SPECIAL;
290+ rq->cmd[0] = cmd;
291+}
292+
293 /*
294 * idetape_queue_pc_head generates a new packet command request in front
295 * of the request queue, before the current request, so that it will be
296@@ -1993,8 +2028,7 @@
297 */
298 static void idetape_queue_pc_head (ide_drive_t *drive, idetape_pc_t *pc,struct request *rq)
299 {
300- memset(rq, 0, sizeof(*rq));
301- rq->flags = REQ_IDETAPE_PC1;
302+ idetape_init_rq(rq, REQ_IDETAPE_PC1);
303 rq->buffer = (char *) pc;
304 (void) ide_do_drive_cmd(drive, rq, ide_preempt);
305 }
306@@ -2430,7 +2464,14 @@
307 if (page_code != IDETAPE_BLOCK_DESCRIPTOR)
308 pc->c[1] = 8; /* DBD = 1 - Don't return block descriptors */
309 pc->c[2] = page_code;
310- pc->c[3] = 255; /* Don't limit the returned information */
311+ /*
312+ * Changed pc->c[3] to 0 (255 will at best return unused info).
313+ *
314+ * For SCSI this byte is defined as subpage instead of high byte
315+ * of length and some IDE drives seem to interpret it this way
316+ * and return an error when 255 is used.
317+ */
318+ pc->c[3] = 0;
319 pc->c[4] = 255; /* (We will just discard data in that case) */
320 if (page_code == IDETAPE_BLOCK_DESCRIPTOR)
321 pc->request_transfer = 12;
322@@ -2544,8 +2585,9 @@
323 if (status.b.dsc) {
324 if (status.b.check) {
325 /* Error detected */
326- printk(KERN_ERR "ide-tape: %s: I/O error, ",tape->name);
327-
328+ if (pc->c[0] != IDETAPE_TEST_UNIT_READY_CMD)
329+ printk(KERN_ERR "ide-tape: %s: I/O error, ",
330+ tape->name);
331 /* Retry operation */
332 return idetape_retry_pc(drive);
333 }
334@@ -2697,7 +2739,7 @@
335 if (tape->debug_level >= 5)
336 printk(KERN_INFO "ide-tape: rq_status: %d, "
337 "dev: %s, cmd: %ld, errors: %d\n", rq->rq_status,
338- rq->rq_disk->disk_name, rq->flags, rq->errors);
339+ rq->rq_disk->disk_name, rq->cmd[0], rq->errors);
340 #endif
341 if (tape->debug_level >= 2)
342 printk(KERN_INFO "ide-tape: sector: %ld, "
343@@ -2705,11 +2747,11 @@
344 rq->sector, rq->nr_sectors, rq->current_nr_sectors);
345 #endif /* IDETAPE_DEBUG_LOG */
346
347- if (!idetape_request(rq)) {
348+ if ((rq->flags & REQ_SPECIAL) == 0) {
349 /*
350 * We do not support buffer cache originated requests.
351 */
352- printk(KERN_NOTICE "ide-tape: %s: Unsupported command in "
353+ printk(KERN_NOTICE "ide-tape: %s: Unsupported request in "
354 "request queue (%ld)\n", drive->name, rq->flags);
355 ide_end_request(drive, 0, 0);
356 return ide_stopped;
357@@ -2746,7 +2788,7 @@
358 */
359 if (tape->onstream)
360 status.b.dsc = 1;
361- if (!drive->dsc_overlap && !(rq->flags & REQ_IDETAPE_PC2))
362+ if (!drive->dsc_overlap && !(rq->cmd[0] & REQ_IDETAPE_PC2))
363 set_bit(IDETAPE_IGNORE_DSC, &tape->flags);
364
365 /*
366@@ -2760,7 +2802,7 @@
367 if (tape->tape_still_time > 100 && tape->tape_still_time < 200)
368 tape->measure_insert_time = 1;
369 if (tape->req_buffer_fill &&
370- (rq->flags & (REQ_IDETAPE_WRITE | REQ_IDETAPE_READ))) {
371+ (rq->cmd[0] & (REQ_IDETAPE_WRITE | REQ_IDETAPE_READ))) {
372 tape->req_buffer_fill = 0;
373 tape->writes_since_buffer_fill = 0;
374 tape->reads_since_buffer_fill = 0;
375@@ -2774,12 +2816,12 @@
376 tape->insert_speed = tape->insert_size / 1024 * HZ / (jiffies - tape->insert_time);
377 calculate_speeds(drive);
378 if (tape->onstream && tape->max_frames &&
379- (((rq->flags & REQ_IDETAPE_WRITE) &&
380+ (((rq->cmd[0] & REQ_IDETAPE_WRITE) &&
381 ( tape->cur_frames == tape->max_frames ||
382 ( tape->speed_control && tape->cur_frames > 5 &&
383 (tape->insert_speed > tape->max_insert_speed ||
384 (0 /* tape->cur_frames > 30 && tape->tape_still_time > 200 */) ) ) ) ) ||
385- ((rq->flags & REQ_IDETAPE_READ) &&
386+ ((rq->cmd[0] & REQ_IDETAPE_READ) &&
387 ( tape->cur_frames == 0 ||
388 ( tape->speed_control && (tape->cur_frames < tape->max_frames - 5) &&
389 tape->insert_speed > tape->max_insert_speed ) ) && rq->nr_sectors) ) ) {
390@@ -2787,7 +2829,7 @@
391 if (tape->debug_level >= 4)
392 printk(KERN_INFO "ide-tape: postponing request, "
393 "cmd %ld, cur %d, max %d\n",
394- rq->flags, tape->cur_frames, tape->max_frames);
395+ rq->cmd[0], tape->cur_frames, tape->max_frames);
396 #endif
397 if (tape->postpone_cnt++ < 500) {
398 status.b.dsc = 0;
399@@ -2808,7 +2850,7 @@
400 } else if ((signed long) (jiffies - tape->dsc_timeout) > 0) {
401 printk(KERN_ERR "ide-tape: %s: DSC timeout\n",
402 tape->name);
403- if (rq->flags & REQ_IDETAPE_PC2) {
404+ if (rq->cmd[0] & REQ_IDETAPE_PC2) {
405 idetape_media_access_finished(drive);
406 return ide_stopped;
407 } else {
408@@ -2819,7 +2861,7 @@
409 idetape_postpone_request(drive);
410 return ide_stopped;
411 }
412- if (rq->flags & REQ_IDETAPE_READ) {
413+ if (rq->cmd[0] & REQ_IDETAPE_READ) {
414 tape->buffer_head++;
415 #if USE_IOTRACE
416 IO_trace(IO_IDETAPE_FIFO, tape->pipeline_head, tape->buffer_head, tape->tape_head, tape->minor);
417@@ -2836,7 +2878,7 @@
418 idetape_create_read_cmd(tape, pc, rq->current_nr_sectors, (struct idetape_bh *)rq->special);
419 goto out;
420 }
421- if (rq->flags & REQ_IDETAPE_WRITE) {
422+ if (rq->cmd[0] & REQ_IDETAPE_WRITE) {
423 tape->buffer_head++;
424 #if USE_IOTRACE
425 IO_trace(IO_IDETAPE_FIFO, tape->pipeline_head, tape->buffer_head, tape->tape_head, tape->minor);
426@@ -2854,19 +2896,19 @@
427 idetape_create_write_cmd(tape, pc, rq->current_nr_sectors, (struct idetape_bh *)rq->special);
428 goto out;
429 }
430- if (rq->flags & REQ_IDETAPE_READ_BUFFER) {
431+ if (rq->cmd[0] & REQ_IDETAPE_READ_BUFFER) {
432 tape->postpone_cnt = 0;
433 pc = idetape_next_pc_storage(drive);
434 idetape_create_read_buffer_cmd(tape, pc, rq->current_nr_sectors, (struct idetape_bh *)rq->special);
435 goto out;
436 }
437- if (rq->flags & REQ_IDETAPE_PC1) {
438+ if (rq->cmd[0] & REQ_IDETAPE_PC1) {
439 pc = (idetape_pc_t *) rq->buffer;
440- rq->flags &= ~(REQ_IDETAPE_PC1);
441- rq->flags |= REQ_IDETAPE_PC2;
442+ rq->cmd[0] &= ~(REQ_IDETAPE_PC1);
443+ rq->cmd[0] |= REQ_IDETAPE_PC2;
444 goto out;
445 }
446- if (rq->flags & REQ_IDETAPE_PC2) {
447+ if (rq->cmd[0] & REQ_IDETAPE_PC2) {
448 idetape_media_access_finished(drive);
449 return ide_stopped;
450 }
451@@ -3163,7 +3205,7 @@
452 idetape_tape_t *tape = drive->driver_data;
453
454 #if IDETAPE_DEBUG_BUGS
455- if (rq == NULL || !idetape_request(rq)) {
456+ if (rq == NULL || (rq->flags & REQ_SPECIAL) == 0) {
457 printk (KERN_ERR "ide-tape: bug: Trying to sleep on non-valid request\n");
458 return;
459 }
460@@ -3269,8 +3311,7 @@
461 {
462 struct request rq;
463
464- memset(&rq, 0, sizeof(rq));
465- rq.flags = REQ_IDETAPE_PC1;
466+ idetape_init_rq(&rq, REQ_IDETAPE_PC1);
467 rq.buffer = (char *) pc;
468 return ide_do_drive_cmd(drive, &rq, ide_wait);
469 }
470@@ -3295,25 +3336,28 @@
471 {
472 idetape_tape_t *tape = drive->driver_data;
473 idetape_pc_t pc;
474+ int load_attempted = 0;
475
476 /*
477 * Wait for the tape to become ready
478 */
479+ set_bit(IDETAPE_MEDIUM_PRESENT, &tape->flags);
480 timeout += jiffies;
481 while (time_before(jiffies, timeout)) {
482 idetape_create_test_unit_ready_cmd(&pc);
483 if (!__idetape_queue_pc_tail(drive, &pc))
484 return 0;
485- if (tape->sense_key == 2 && tape->asc == 4 && tape->ascq == 2) {
486+ if ((tape->sense_key == 2 && tape->asc == 4 && tape->ascq == 2)
487+ || (tape->asc == 0x3A)) { /* no media */
488+ if (load_attempted)
489+ return -ENOMEDIUM;
490 idetape_create_load_unload_cmd(drive, &pc, IDETAPE_LU_LOAD_MASK);
491 __idetape_queue_pc_tail(drive, &pc);
492- idetape_create_test_unit_ready_cmd(&pc);
493- if (!__idetape_queue_pc_tail(drive, &pc))
494- return 0;
495- }
496- if (!(tape->sense_key == 2 && tape->asc == 4 &&
497- (tape->ascq == 1 || tape->ascq == 8)))
498- break;
499+ load_attempted = 1;
500+ /* not about to be ready */
501+ } else if (!(tape->sense_key == 2 && tape->asc == 4 &&
502+ (tape->ascq == 1 || tape->ascq == 8)))
503+ return -EIO;
504 current->state = TASK_INTERRUPTIBLE;
505 schedule_timeout(HZ / 10);
506 }
507@@ -3369,25 +3413,10 @@
508 printk(KERN_INFO "ide-tape: Reached idetape_read_position\n");
509 #endif /* IDETAPE_DEBUG_LOG */
510
511-#ifdef NO_LONGER_REQUIRED
512- idetape_flush_tape_buffers(drive);
513-#endif
514 idetape_create_read_position_cmd(&pc);
515 if (idetape_queue_pc_tail(drive, &pc))
516 return -1;
517 position = tape->first_frame_position;
518-#ifdef NO_LONGER_REQUIRED
519- if (tape->onstream) {
520- if ((position != tape->last_frame_position - tape->blocks_in_buffer) &&
521- (position != tape->last_frame_position + tape->blocks_in_buffer)) {
522- if (tape->blocks_in_buffer == 0) {
523- printk("ide-tape: %s: correcting read position %d, %d, %d\n", tape->name, position, tape->last_frame_position, tape->blocks_in_buffer);
524- position = tape->last_frame_position;
525- tape->first_frame_position = position;
526- }
527- }
528- }
529-#endif
530 return position;
531 }
532
533@@ -3436,6 +3465,8 @@
534
535 if (tape->chrdev_direction != idetape_direction_read)
536 return 0;
537+
538+ /* Remove merge stage. */
539 cnt = tape->merge_stage_size / tape->tape_block_size;
540 if (test_and_clear_bit(IDETAPE_FILEMARK, &tape->flags))
541 ++cnt; /* Filemarks count as 1 sector */
542@@ -3444,9 +3475,12 @@
543 __idetape_kfree_stage(tape->merge_stage);
544 tape->merge_stage = NULL;
545 }
546+
547+ /* Clear pipeline flags. */
548 clear_bit(IDETAPE_PIPELINE_ERROR, &tape->flags);
549 tape->chrdev_direction = idetape_direction_none;
550-
551+
552+ /* Remove pipeline stages. */
553 if (tape->first_stage == NULL)
554 return 0;
555
556@@ -3546,8 +3580,7 @@
557 }
558 #endif /* IDETAPE_DEBUG_BUGS */
559
560- memset(&rq, 0, sizeof(rq));
561- rq.flags = cmd;
562+ idetape_init_rq(&rq, cmd);
563 rq.special = (void *)bh;
564 rq.sector = tape->first_frame_position;
565 rq.nr_sectors = rq.current_nr_sectors = blocks;
566@@ -3596,8 +3629,7 @@
567 printk(KERN_INFO "ide-tape: %s: read back logical block %d, data %x %x %x %x\n", tape->name, logical_blk_num, *p++, *p++, *p++, *p++);
568 #endif
569 rq = &stage->rq;
570- memset(rq, 0, sizeof(*rq));
571- rq->flags = REQ_IDETAPE_WRITE;
572+ idetape_init_rq(rq, REQ_IDETAPE_WRITE);
573 rq->sector = tape->first_frame_position;
574 rq->nr_sectors = rq->current_nr_sectors = tape->capabilities.ctl;
575 idetape_init_stage(drive, stage, OS_FRAME_TYPE_DATA, logical_blk_num++);
576@@ -3871,8 +3903,7 @@
577 }
578 }
579 rq = &new_stage->rq;
580- memset(rq, 0, sizeof(*rq));
581- rq->flags = REQ_IDETAPE_WRITE;
582+ idetape_init_rq(rq, REQ_IDETAPE_WRITE);
583 /* Doesn't actually matter - We always assume sequential access */
584 rq->sector = tape->first_frame_position;
585 rq->nr_sectors = rq->current_nr_sectors = blocks;
586@@ -4059,19 +4090,22 @@
587 * Issue a read 0 command to ensure that DSC handshake
588 * is switched from completion mode to buffer available
589 * mode.
590+ * No point in issuing this if DSC overlap isn't supported,
591+ * some drives (Seagate STT3401A) will return an error.
592 */
593- bytes_read = idetape_queue_rw_tail(drive, REQ_IDETAPE_READ, 0, tape->merge_stage->bh);
594- if (bytes_read < 0) {
595- __idetape_kfree_stage(tape->merge_stage);
596- tape->merge_stage = NULL;
597- tape->chrdev_direction = idetape_direction_none;
598- return bytes_read;
599+ if (drive->dsc_overlap) {
600+ bytes_read = idetape_queue_rw_tail(drive, REQ_IDETAPE_READ, 0, tape->merge_stage->bh);
601+ if (bytes_read < 0) {
602+ __idetape_kfree_stage(tape->merge_stage);
603+ tape->merge_stage = NULL;
604+ tape->chrdev_direction = idetape_direction_none;
605+ return bytes_read;
606+ }
607 }
608 }
609 if (tape->restart_speed_control_req)
610 idetape_restart_speed_control(drive);
611- memset(&rq, 0, sizeof(rq));
612- rq.flags = REQ_IDETAPE_READ;
613+ idetape_init_rq(&rq, REQ_IDETAPE_READ);
614 rq.sector = tape->first_frame_position;
615 rq.nr_sectors = rq.current_nr_sectors = blocks;
616 if (!test_bit(IDETAPE_PIPELINE_ERROR, &tape->flags) &&
617@@ -4898,6 +4932,10 @@
618 return -ENXIO;
619 }
620
621+ /* The drive is write protected. */
622+ if (tape->write_prot)
623+ return -EACCES;
624+
625 #if IDETAPE_DEBUG_LOG
626 if (tape->debug_level >= 3)
627 printk(KERN_INFO "ide-tape: Reached idetape_chrdev_write, "
628@@ -4979,13 +5017,17 @@
629 * Issue a write 0 command to ensure that DSC handshake
630 * is switched from completion mode to buffer available
631 * mode.
632+ * No point in issuing this if DSC overlap isn't supported,
633+ * some drives (Seagate STT3401A) will return an error.
634 */
635- retval = idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE, 0, tape->merge_stage->bh);
636- if (retval < 0) {
637- __idetape_kfree_stage(tape->merge_stage);
638- tape->merge_stage = NULL;
639- tape->chrdev_direction = idetape_direction_none;
640- return retval;
641+ if (drive->dsc_overlap) {
642+ retval = idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE, 0, tape->merge_stage->bh);
643+ if (retval < 0) {
644+ __idetape_kfree_stage(tape->merge_stage);
645+ tape->merge_stage = NULL;
646+ tape->chrdev_direction = idetape_direction_none;
647+ return retval;
648+ }
649 }
650 #if ONSTREAM_DEBUG
651 if (tape->debug_level >= 2)
652@@ -5141,7 +5183,7 @@
653 * Note:
654 *
655 * MTBSF and MTBSFM are not supported when the tape doesn't
656- * supports spacing over filemarks in the reverse direction.
657+ * support spacing over filemarks in the reverse direction.
658 * In this case, MTFSFM is also usually not supported (it is
659 * supported in the rare case in which we crossed the filemark
660 * during our read-ahead pipelined operation mode).
661@@ -5211,6 +5253,8 @@
662 }
663 switch (mt_op) {
664 case MTWEOF:
665+ if (tape->write_prot)
666+ return -EACCES;
667 idetape_discard_read_pipeline(drive, 1);
668 for (i = 0; i < mt_count; i++) {
669 retval = idetape_write_filemark(drive);
670@@ -5231,9 +5275,21 @@
671 return (idetape_queue_pc_tail(drive, &pc));
672 case MTUNLOAD:
673 case MTOFFL:
674+ /*
675+ * If door is locked, attempt to unlock before
676+ * attempting to eject.
677+ */
678+ if (tape->door_locked) {
679+ if (idetape_create_prevent_cmd(drive, &pc, 0))
680+ if (!idetape_queue_pc_tail(drive, &pc))
681+ tape->door_locked = DOOR_UNLOCKED;
682+ }
683 idetape_discard_read_pipeline(drive, 0);
684 idetape_create_load_unload_cmd(drive, &pc,!IDETAPE_LU_LOAD_MASK);
685- return (idetape_queue_pc_tail(drive, &pc));
686+ retval = idetape_queue_pc_tail(drive, &pc);
687+ if (!retval)
688+ clear_bit(IDETAPE_MEDIUM_PRESENT, &tape->flags);
689+ return retval;
690 case MTNOP:
691 idetape_discard_read_pipeline(drive, 0);
692 return (idetape_flush_tape_buffers(drive));
693@@ -5409,6 +5465,8 @@
694 mtget.mt_gstat |= GMT_EOD(0xffffffff);
695 if (position <= OS_DATA_STARTFRAME1)
696 mtget.mt_gstat |= GMT_BOT(0xffffffff);
697+ } else if (tape->drv_write_prot) {
698+ mtget.mt_gstat |= GMT_WR_PROT(0xffffffff);
699 }
700 if (copy_to_user((char *) arg,(char *) &mtget, sizeof(struct mtget)))
701 return -EFAULT;
702@@ -5530,6 +5588,8 @@
703 return 1;
704 }
705
706+static void idetape_get_blocksize_from_block_descriptor(ide_drive_t *drive);
707+
708 /*
709 * Our character device open function.
710 */
711@@ -5539,7 +5599,8 @@
712 ide_drive_t *drive;
713 idetape_tape_t *tape;
714 idetape_pc_t pc;
715-
716+ int retval;
717+
718 #if IDETAPE_DEBUG_LOG
719 printk(KERN_INFO "ide-tape: Reached idetape_chrdev_open\n");
720 #endif /* IDETAPE_DEBUG_LOG */
721@@ -5552,11 +5613,7 @@
722
723 if (test_and_set_bit(IDETAPE_BUSY, &tape->flags))
724 return -EBUSY;
725- if (!tape->onstream) {
726- idetape_read_position(drive);
727- if (!test_bit(IDETAPE_ADDRESS_VALID, &tape->flags))
728- (void) idetape_rewind_tape(drive);
729- } else {
730+ if (tape->onstream) {
731 if (minor & 64) {
732 tape->tape_block_size = tape->stage_size = 32768 + 512;
733 tape->raw = 1;
734@@ -5566,16 +5623,42 @@
735 }
736 idetape_onstream_mode_sense_tape_parameter_page(drive, tape->debug_level);
737 }
738- if (idetape_wait_ready(drive, 60 * HZ)) {
739+ retval = idetape_wait_ready(drive, 60 * HZ);
740+ if (retval) {
741 clear_bit(IDETAPE_BUSY, &tape->flags);
742 printk(KERN_ERR "ide-tape: %s: drive not ready\n", tape->name);
743- return -EBUSY;
744+ return retval;
745 }
746- if (tape->onstream)
747- idetape_read_position(drive);
748+
749+ idetape_read_position(drive);
750+ if (!test_bit(IDETAPE_ADDRESS_VALID, &tape->flags))
751+ (void)idetape_rewind_tape(drive);
752+
753 if (tape->chrdev_direction != idetape_direction_read)
754 clear_bit(IDETAPE_PIPELINE_ERROR, &tape->flags);
755
756+ /* Read block size and write protect status from drive. */
757+ idetape_get_blocksize_from_block_descriptor(drive);
758+
759+ /* Set write protect flag if device is opened as read-only. */
760+ if ((filp->f_flags & O_ACCMODE) == O_RDONLY)
761+ tape->write_prot = 1;
762+ else
763+ tape->write_prot = tape->drv_write_prot;
764+
765+ /* Make sure drive isn't write protected if user wants to write. */
766+ if (tape->write_prot) {
767+ if ((filp->f_flags & O_ACCMODE) == O_WRONLY ||
768+ (filp->f_flags & O_ACCMODE) == O_RDWR) {
769+ clear_bit(IDETAPE_BUSY, &tape->flags);
770+ return -EROFS;
771+ }
772+ }
773+
774+ /*
775+ * Lock the tape drive door so user can't eject.
776+ * Analyze headers for OnStream drives.
777+ */
778 if (tape->chrdev_direction == idetape_direction_none) {
779 if (idetape_create_prevent_cmd(drive, &pc, 1)) {
780 if (!idetape_queue_pc_tail(drive, &pc)) {
781@@ -5638,7 +5721,7 @@
782 __idetape_kfree_stage(tape->cache_stage);
783 tape->cache_stage = NULL;
784 }
785- if (minor < 128)
786+ if (minor < 128 && test_bit(IDETAPE_MEDIUM_PRESENT, &tape->flags))
787 (void) idetape_rewind_tape(drive);
788 if (tape->chrdev_direction == idetape_direction_none) {
789 if (tape->door_locked == DOOR_LOCKED) {
790@@ -6059,6 +6142,8 @@
791 header = (idetape_mode_parameter_header_t *) pc.buffer;
792 block_descrp = (idetape_parameter_block_descriptor_t *) (pc.buffer + sizeof(idetape_mode_parameter_header_t));
793 tape->tape_block_size =( block_descrp->length[0]<<16) + (block_descrp->length[1]<<8) + block_descrp->length[2];
794+ tape->drv_write_prot = (header->dsp & 0x80) >> 7;
795+
796 #if IDETAPE_DEBUG_INFO
797 printk(KERN_INFO "ide-tape: Adjusted block size - %d\n", tape->tape_block_size);
798 #endif /* IDETAPE_DEBUG_INFO */
799@@ -6139,6 +6224,9 @@
800 }
801 }
802 #endif /* CONFIG_BLK_DEV_IDEPCI */
803+ /* Seagate Travan drives do not support DSC overlap. */
804+ if (strstr(drive->id->model, "Seagate STT3401"))
805+ drive->dsc_overlap = 0;
806 tape->drive = drive;
807 tape->minor = minor;
808 tape->name[0] = 'h';
809diff -uNr -X exclude linux-2.6.0-test11/drivers/ide/pci/cmd640.c linux/drivers/ide/pci/cmd640.c
810--- linux-2.6.0-test11/drivers/ide/pci/cmd640.c 2003-12-08 00:29:13.000000000 +0100
811+++ linux/drivers/ide/pci/cmd640.c 2003-12-08 00:33:51.864083168 +0100
812@@ -213,13 +213,13 @@
813
814 static void put_cmd640_reg_pci1 (u16 reg, u8 val)
815 {
816- outb_p((reg & 0xfc) | cmd640_key, 0xcf8);
817+ outl_p((reg & 0xfc) | cmd640_key, 0xcf8);
818 outb_p(val, (reg & 3) | 0xcfc);
819 }
820
821 static u8 get_cmd640_reg_pci1 (u16 reg)
822 {
823- outb_p((reg & 0xfc) | cmd640_key, 0xcf8);
824+ outl_p((reg & 0xfc) | cmd640_key, 0xcf8);
825 return inb_p((reg & 3) | 0xcfc);
826 }
827
828diff -uNr -X exclude linux-2.6.0-test11/drivers/ide/pci/pdc202xx_new.c linux/drivers/ide/pci/pdc202xx_new.c
829--- linux-2.6.0-test11/drivers/ide/pci/pdc202xx_new.c 2003-12-08 00:29:12.000000000 +0100
830+++ linux/drivers/ide/pci/pdc202xx_new.c 2003-12-08 00:33:52.996910952 +0100
831@@ -36,60 +36,20 @@
832
833 #define PDC202_DEBUG_CABLE 0
834
835-#if defined(DISPLAY_PDC202XX_TIMINGS) && defined(CONFIG_PROC_FS)
836-#include <linux/stat.h>
837-#include <linux/proc_fs.h>
838-
839-static u8 pdcnew_proc = 0;
840-#define PDC202_MAX_DEVS 5
841-static struct pci_dev *pdc202_devs[PDC202_MAX_DEVS];
842-static int n_pdc202_devs;
843-
844-static char * pdcnew_info(char *buf, struct pci_dev *dev)
845-{
846- char *p = buf;
847-
848- p += sprintf(p, "\n ");
849- switch(dev->device) {
850- case PCI_DEVICE_ID_PROMISE_20277:
851- p += sprintf(p, "SBFastTrak 133 Lite"); break;
852- case PCI_DEVICE_ID_PROMISE_20276:
853- p += sprintf(p, "MBFastTrak 133 Lite"); break;
854- case PCI_DEVICE_ID_PROMISE_20275:
855- p += sprintf(p, "MBUltra133"); break;
856- case PCI_DEVICE_ID_PROMISE_20271:
857- p += sprintf(p, "FastTrak TX2000"); break;
858- case PCI_DEVICE_ID_PROMISE_20270:
859- p += sprintf(p, "FastTrak LP/TX2/TX4"); break;
860- case PCI_DEVICE_ID_PROMISE_20269:
861- p += sprintf(p, "Ultra133 TX2"); break;
862- case PCI_DEVICE_ID_PROMISE_20268:
863- p += sprintf(p, "Ultra100 TX2"); break;
864- default:
865- p += sprintf(p, "Ultra series"); break;
866- break;
867- }
868- p += sprintf(p, " Chipset.\n");
869- return (char *)p;
870-}
871-
872-static int pdcnew_get_info (char *buffer, char **addr, off_t offset, int count)
873-{
874- char *p = buffer;
875- int i, len;
876-
877- for (i = 0; i < n_pdc202_devs; i++) {
878- struct pci_dev *dev = pdc202_devs[i];
879- p = pdcnew_info(buffer, dev);
880- }
881- /* p - buffer must be less than 4k! */
882- len = (p - buffer) - offset;
883- *addr = buffer + offset;
884-
885- return len > count ? count : len;
886-}
887-#endif /* defined(DISPLAY_PDC202XX_TIMINGS) && defined(CONFIG_PROC_FS) */
888+struct pdcnew_name {
889+ u16 dev_id;
890+ const char *name;
891+};
892
893+static struct pdcnew_name __initdata pdcnew_names[] = {
894+ { PCI_DEVICE_ID_PROMISE_20277, "SBFastTrak 133 Lite" },
895+ { PCI_DEVICE_ID_PROMISE_20276, "MBFastTrak 133 Lite" },
896+ { PCI_DEVICE_ID_PROMISE_20275, "MBUltra133", },
897+ { PCI_DEVICE_ID_PROMISE_20271, "FastTrak TX2000", },
898+ { PCI_DEVICE_ID_PROMISE_20270, "FastTrak LP/TX2/TX4", },
899+ { PCI_DEVICE_ID_PROMISE_20269, "Ultra133 TX2" },
900+ { PCI_DEVICE_ID_PROMISE_20268, "Ultra100 TX2" },
901+};
902
903 static u8 pdcnew_ratemask (ide_drive_t *drive)
904 {
905@@ -515,6 +475,15 @@
906
907 static unsigned int __init init_chipset_pdcnew (struct pci_dev *dev, const char *name)
908 {
909+ unsigned int i;
910+
911+ for (i = 0; i < ARRAY_SIZE(pdcnew_names); i++)
912+ if (pdcnew_names[i].dev_id == dev->device) {
913+ printk(KERN_INFO "%s: %s on pci%s\n", name,
914+ pdcnew_names[i].name, pci_name(dev));
915+ break;
916+ }
917+
918 if (dev->resource[PCI_ROM_RESOURCE].start) {
919 pci_write_config_dword(dev, PCI_ROM_ADDRESS,
920 dev->resource[PCI_ROM_RESOURCE].start | PCI_ROM_ADDRESS_ENABLE);
921@@ -522,15 +491,6 @@
922 name, dev->resource[PCI_ROM_RESOURCE].start);
923 }
924
925-#if defined(DISPLAY_PDC202XX_TIMINGS) && defined(CONFIG_PROC_FS)
926- pdc202_devs[n_pdc202_devs++] = dev;
927-
928- if (!pdcnew_proc) {
929- pdcnew_proc = 1;
930- ide_pci_register_host_proc(&pdcnew_procs[0]);
931- }
932-#endif /* DISPLAY_PDC202XX_TIMINGS && CONFIG_PROC_FS */
933-
934 return dev->irq;
935 }
936
937diff -uNr -X exclude linux-2.6.0-test11/drivers/ide/pci/pdc202xx_new.h linux/drivers/ide/pci/pdc202xx_new.h
938--- linux-2.6.0-test11/drivers/ide/pci/pdc202xx_new.h 2003-12-08 00:29:12.000000000 +0100
939+++ linux/drivers/ide/pci/pdc202xx_new.h 2003-12-08 00:33:52.997910800 +0100
940@@ -5,8 +5,6 @@
941 #include <linux/pci.h>
942 #include <linux/ide.h>
943
944-#define DISPLAY_PDC202XX_TIMINGS
945-
946 #ifndef SPLIT_BYTE
947 #define SPLIT_BYTE(B,H,L) ((H)=(B>>4), (L)=(B-((B>>4)<<4)))
948 #endif
949@@ -162,27 +160,6 @@
950 set_2regs(0x13,(c)); \
951 } while(0)
952
953-#define DISPLAY_PDC202XX_TIMINGS
954-
955-#if defined(DISPLAY_PDC202XX_TIMINGS) && defined(CONFIG_PROC_FS)
956-#include <linux/stat.h>
957-#include <linux/proc_fs.h>
958-
959-static u8 pdcnew_proc;
960-
961-static int pdcnew_get_info(char *, char **, off_t, int);
962-
963-static ide_pci_host_proc_t pdcnew_procs[] __initdata = {
964- {
965- .name = "pdcnew",
966- .set = 1,
967- .get_info = pdcnew_get_info,
968- .parent = NULL,
969- },
970-};
971-#endif /* DISPLAY_PDC202XX_TIMINGS && CONFIG_PROC_FS */
972-
973-
974 static void init_setup_pdcnew(struct pci_dev *, ide_pci_device_t *);
975 static void init_setup_pdc20270(struct pci_dev *, ide_pci_device_t *);
976 static void init_setup_pdc20276(struct pci_dev *dev, ide_pci_device_t *d);
977diff -uNr -X exclude linux-2.6.0-test11/drivers/ide/pci/pdc202xx_old.c linux/drivers/ide/pci/pdc202xx_old.c
978--- linux-2.6.0-test11/drivers/ide/pci/pdc202xx_old.c 2003-12-08 00:29:12.000000000 +0100
979+++ linux/drivers/ide/pci/pdc202xx_old.c 2003-12-08 00:33:52.369006408 +0100
980@@ -361,16 +361,38 @@
981 return ((u8)(CIS & mask));
982 }
983
984+/*
985+ * Set the control register to use the 66MHz system
986+ * clock for UDMA 3/4/5 mode operation when necessary.
987+ *
988+ * It may also be possible to leave the 66MHz clock on
989+ * and readjust the timing parameters.
990+ */
991+static void pdc_old_enable_66MHz_clock(ide_hwif_t *hwif)
992+{
993+ unsigned long clock_reg = hwif->dma_master + 0x11;
994+ u8 clock = hwif->INB(clock_reg);
995+
996+ hwif->OUTB(clock | (hwif->channel ? 0x08 : 0x02), clock_reg);
997+}
998+
999+static void pdc_old_disable_66MHz_clock(ide_hwif_t *hwif)
1000+{
1001+ unsigned long clock_reg = hwif->dma_master + 0x11;
1002+ u8 clock = hwif->INB(clock_reg);
1003+
1004+ hwif->OUTB(clock & ~(hwif->channel ? 0x08 : 0x02), clock_reg);
1005+}
1006+
1007 static int config_chipset_for_dma (ide_drive_t *drive)
1008 {
1009 struct hd_driveid *id = drive->id;
1010 ide_hwif_t *hwif = HWIF(drive);
1011 struct pci_dev *dev = hwif->pci_dev;
1012 u32 drive_conf = 0;
1013- u8 mask = hwif->channel ? 0x08 : 0x02;
1014 u8 drive_pci = 0x60 + (drive->dn << 2);
1015 u8 test1 = 0, test2 = 0, speed = -1;
1016- u8 AP = 0, CLKSPD = 0, cable = 0;
1017+ u8 AP = 0, cable = 0;
1018
1019 u8 ultra_66 = ((id->dma_ultra & 0x0010) ||
1020 (id->dma_ultra & 0x0008)) ? 1 : 0;
1021@@ -394,21 +416,6 @@
1022 BUG();
1023 }
1024
1025- CLKSPD = hwif->INB(hwif->dma_master + 0x11);
1026-
1027- /*
1028- * Set the control register to use the 66Mhz system
1029- * clock for UDMA 3/4 mode operation. If one drive on
1030- * a channel is U66 capable but the other isn't we
1031- * fall back to U33 mode. The BIOS INT 13 hooks turn
1032- * the clock on then off for each read/write issued. I don't
1033- * do that here because it would require modifying the
1034- * kernel, separating the fop routines from the kernel or
1035- * somehow hooking the fops calls. It may also be possible to
1036- * leave the 66Mhz clock on and readjust the timing
1037- * parameters.
1038- */
1039-
1040 if ((ultra_66) && (cable)) {
1041 #ifdef DEBUG
1042 printk(KERN_DEBUG "ULTRA 66/100/133: %s channel of Ultra 66/100/133 "
1043@@ -416,29 +423,12 @@
1044 hwif->channel ? "Secondary" : "Primary");
1045 printk(KERN_DEBUG " Switching to Ultra33 mode.\n");
1046 #endif /* DEBUG */
1047- /* Primary : zero out second bit */
1048- /* Secondary : zero out fourth bit */
1049- hwif->OUTB(CLKSPD & ~mask, (hwif->dma_master + 0x11));
1050 printk(KERN_WARNING "Warning: %s channel requires an 80-pin cable for operation.\n", hwif->channel ? "Secondary":"Primary");
1051 printk(KERN_WARNING "%s reduced to Ultra33 mode.\n", drive->name);
1052- } else {
1053- if (ultra_66) {
1054- /*
1055- * check to make sure drive on same channel
1056- * is u66 capable
1057- */
1058- if (hwif->drives[!(drive->dn%2)].id) {
1059- if (hwif->drives[!(drive->dn%2)].id->dma_ultra & 0x0078) {
1060- hwif->OUTB(CLKSPD | mask, (hwif->dma_master + 0x11));
1061- } else {
1062- hwif->OUTB(CLKSPD & ~mask, (hwif->dma_master + 0x11));
1063- }
1064- } else { /* udma4 drive by itself */
1065- hwif->OUTB(CLKSPD | mask, (hwif->dma_master + 0x11));
1066- }
1067- }
1068 }
1069
1070+ pdc_old_disable_66MHz_clock(drive->hwif);
1071+
1072 drive_pci = 0x60 + (drive->dn << 2);
1073 pci_read_config_dword(dev, drive_pci, &drive_conf);
1074 if ((drive_conf != 0x004ff304) && (drive_conf != 0x004ff3c4))
1075@@ -536,6 +526,8 @@
1076
1077 static int pdc202xx_old_ide_dma_begin(ide_drive_t *drive)
1078 {
1079+ if (drive->current_speed > XFER_UDMA_2)
1080+ pdc_old_enable_66MHz_clock(drive->hwif);
1081 if (drive->addressing == 1) {
1082 struct request *rq = HWGROUP(drive)->rq;
1083 ide_hwif_t *hwif = HWIF(drive);
1084@@ -569,6 +561,8 @@
1085 clock = hwif->INB(high_16 + 0x11);
1086 hwif->OUTB(clock & ~(hwif->channel ? 0x08:0x02), high_16+0x11);
1087 }
1088+ if (drive->current_speed > XFER_UDMA_2)
1089+ pdc_old_disable_66MHz_clock(drive->hwif);
1090 return __ide_dma_end(drive);
1091 }
1092
1093@@ -757,10 +751,7 @@
1094
1095 hwif->speedproc = &pdc202xx_tune_chipset;
1096
1097- if (!hwif->dma_base) {
1098- hwif->drives[0].autotune = hwif->drives[1].autotune = 1;
1099- return;
1100- }
1101+ hwif->drives[0].autotune = hwif->drives[1].autotune = 1;
1102
1103 hwif->ultra_mask = 0x3f;
1104 hwif->mwdma_mask = 0x07;
1105diff -uNr -X exclude linux-2.6.0-test11/drivers/ide/pci/siimage.c linux/drivers/ide/pci/siimage.c
1106--- linux-2.6.0-test11/drivers/ide/pci/siimage.c 2003-12-08 00:29:13.000000000 +0100
1107+++ linux/drivers/ide/pci/siimage.c 2003-12-08 00:33:51.712106272 +0100
1108@@ -1,5 +1,5 @@
1109 /*
1110- * linux/drivers/ide/pci/siimage.c Version 1.06 June 11, 2003
1111+ * linux/drivers/ide/pci/siimage.c Version 1.09 Dec 7, 2003
1112 *
1113 * Copyright (C) 2001-2002 Andre Hedrick <andre@linux-ide.org>
1114 * Copyright (C) 2003 Red Hat <alan@redhat.com>
1115@@ -56,6 +56,7 @@
1116 {
1117 case PCI_DEVICE_ID_SII_3112:
1118 case PCI_DEVICE_ID_SII_1210SA:
1119+ case PCI_DEVICE_ID_SII_3114:
1120 return 1;
1121 case PCI_DEVICE_ID_SII_680:
1122 return 0;
1123@@ -266,7 +267,7 @@
1124 static void siimage_tuneproc (ide_drive_t *drive, byte mode_wanted)
1125 {
1126 ide_hwif_t *hwif = HWIF(drive);
1127- u32 speedt = 0;
1128+ u16 speedt = 0;
1129 u16 speedp = 0;
1130 unsigned long addr = siimage_seldev(drive, 0x04);
1131 unsigned long tfaddr = siimage_selreg(hwif, 0x02);
1132@@ -1047,6 +1048,27 @@
1133 hwif->mmio = 2;
1134 }
1135
1136+static int is_dev_seagate_sata(ide_drive_t *drive)
1137+{
1138+ const char *s = &drive->id->model[0];
1139+ unsigned len;
1140+
1141+ if (!drive->present)
1142+ return 0;
1143+
1144+ len = strnlen(s, sizeof(drive->id->model));
1145+
1146+ if ((len > 4) && (!memcmp(s, "ST", 2))) {
1147+ if ((!memcmp(s + len - 2, "AS", 2)) ||
1148+ (!memcmp(s + len - 3, "ASL", 3))) {
1149+ printk(KERN_INFO "%s: applying pessimistic Seagate "
1150+ "errata fix\n", drive->name);
1151+ return 1;
1152+ }
1153+ }
1154+ return 0;
1155+}
1156+
1157 /**
1158 * init_iops_siimage - set up iops
1159 * @hwif: interface to set up
1160@@ -1068,7 +1090,7 @@
1161 hwif->hwif_data = 0;
1162
1163 hwif->rqsize = 128;
1164- if (is_sata(hwif))
1165+ if (is_sata(hwif) && is_dev_seagate_sata(&hwif->drives[0]))
1166 hwif->rqsize = 15;
1167
1168 if (pci_get_drvdata(dev) == NULL)
1169@@ -1179,6 +1201,7 @@
1170 { PCI_VENDOR_ID_CMD, PCI_DEVICE_ID_SII_680, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
1171 { PCI_VENDOR_ID_CMD, PCI_DEVICE_ID_SII_3112, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
1172 { PCI_VENDOR_ID_CMD, PCI_DEVICE_ID_SII_1210SA, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
1173+ { PCI_VENDOR_ID_CMD, PCI_DEVICE_ID_SII_3114, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3},
1174 { 0, },
1175 };
1176
1177diff -uNr -X exclude linux-2.6.0-test11/drivers/ide/pci/siimage.h linux/drivers/ide/pci/siimage.h
1178--- linux-2.6.0-test11/drivers/ide/pci/siimage.h 2003-12-08 00:29:13.000000000 +0100
1179+++ linux/drivers/ide/pci/siimage.h 2003-12-08 00:33:51.713106120 +0100
1180@@ -82,6 +82,16 @@
1181 .enablebits = {{0x00,0x00,0x00}, {0x00,0x00,0x00}},
1182 .bootable = ON_BOARD,
1183 .extra = 0,
1184+ },{ /* 3 */
1185+ .vendor = PCI_VENDOR_ID_CMD,
1186+ .device = PCI_DEVICE_ID_SII_3114,
1187+ .name = "SiI3114 Serial ATA",
1188+ .init_chipset = init_chipset_siimage,
1189+ .init_iops = init_iops_siimage,
1190+ .init_hwif = init_hwif_siimage,
1191+ .channels = 2,
1192+ .autodma = AUTODMA,
1193+ .bootable = ON_BOARD,
1194 },{
1195 .vendor = 0,
1196 .device = 0,
1197diff -uNr -X exclude linux-2.6.0-test11/include/linux/blkdev.h linux/include/linux/blkdev.h
1198--- linux-2.6.0-test11/include/linux/blkdev.h 2003-12-08 00:29:13.000000000 +0100
1199+++ linux/include/linux/blkdev.h 2003-12-08 00:33:51.208182880 +0100
1200@@ -193,11 +193,6 @@
1201 __REQ_PM_SUSPEND, /* suspend request */
1202 __REQ_PM_RESUME, /* resume request */
1203 __REQ_PM_SHUTDOWN, /* shutdown request */
1204- __REQ_IDETAPE_PC1, /* packet command (first stage) */
1205- __REQ_IDETAPE_PC2, /* packet command (second stage) */
1206- __REQ_IDETAPE_READ,
1207- __REQ_IDETAPE_WRITE,
1208- __REQ_IDETAPE_READ_BUFFER,
1209 __REQ_NR_BITS, /* stops here */
1210 };
1211
1212@@ -223,11 +218,6 @@
1213 #define REQ_PM_SUSPEND (1 << __REQ_PM_SUSPEND)
1214 #define REQ_PM_RESUME (1 << __REQ_PM_RESUME)
1215 #define REQ_PM_SHUTDOWN (1 << __REQ_PM_SHUTDOWN)
1216-#define REQ_IDETAPE_PC1 (1 << __REQ_IDETAPE_PC1)
1217-#define REQ_IDETAPE_PC2 (1 << __REQ_IDETAPE_PC2)
1218-#define REQ_IDETAPE_READ (1 << __REQ_IDETAPE_READ)
1219-#define REQ_IDETAPE_WRITE (1 << __REQ_IDETAPE_WRITE)
1220-#define REQ_IDETAPE_READ_BUFFER (1 << __REQ_IDETAPE_READ_BUFFER)
1221
1222 /*
1223 * State information carried for REQ_PM_SUSPEND and REQ_PM_RESUME
1224diff -uNr -X exclude linux-2.6.0-test11/include/linux/ide.h linux/include/linux/ide.h
1225--- linux-2.6.0-test11/include/linux/ide.h 2003-12-08 00:29:12.000000000 +0100
1226+++ linux/include/linux/ide.h 2003-12-08 00:33:52.836935272 +0100
1227@@ -51,9 +51,6 @@
1228 #ifndef SUPPORT_VLB_SYNC /* 1 to support weird 32-bit chips */
1229 #define SUPPORT_VLB_SYNC 1 /* 0 to reduce kernel size */
1230 #endif
1231-#ifndef DISK_RECOVERY_TIME /* off=0; on=access_delay_time */
1232-#define DISK_RECOVERY_TIME 0 /* for hardware that needs it */
1233-#endif
1234 #ifndef OK_TO_RESET_CONTROLLER /* 1 needed for good error recovery */
1235 #define OK_TO_RESET_CONTROLLER 1 /* 0 for use with AH2372A/B interface */
1236 #endif
1237@@ -999,10 +996,6 @@
1238 unsigned dma_extra; /* extra addr for dma ports */
1239 unsigned long config_data; /* for use by chipset-specific code */
1240 unsigned long select_data; /* for use by chipset-specific code */
1241-#if (DISK_RECOVERY_TIME > 0)
1242- unsigned long last_time; /* time when previous rq was done */
1243-#endif
1244-
1245
1246 unsigned noprobe : 1; /* don't probe for this interface */
1247 unsigned present : 1; /* this interface exists */
1248diff -uNr -X exclude linux-2.6.0-test11/include/linux/pci_ids.h linux/include/linux/pci_ids.h
1249--- linux-2.6.0-test11/include/linux/pci_ids.h 2003-12-08 00:29:13.000000000 +0100
1250+++ linux/include/linux/pci_ids.h 2003-12-08 00:33:51.715105816 +0100
1251@@ -882,6 +882,7 @@
1252
1253 #define PCI_DEVICE_ID_SII_680 0x0680
1254 #define PCI_DEVICE_ID_SII_3112 0x3112
1255+#define PCI_DEVICE_ID_SII_3114 0x3114
1256 #define PCI_DEVICE_ID_SII_1210SA 0x0240
1257
1258 #define PCI_VENDOR_ID_VISION 0x1098
The Linux kernel (the core of the Linux operating system)
This page took 0.213983 seconds and 4 git commands to generate.