Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge master.kernel.org:/pub/scm/linux/kernel/git/bart/ide-2.6
* master.kernel.org:/pub/scm/linux/kernel/git/bart/ide-2.6:
scc_pata: PIO fixes
piix/slc90e66: fix PIO1 handling in ->speedproc method (take 2)
jmicron: PIO fixes
it8213: PIO fixes (take 2)
cs5535: PIO fixes
cs5520: fix PIO auto-tuning in ->ide_dma_check method
drivers/scsi/ide-scsi.c: kmalloc + memset conversion to kzalloc
drivers/ide/arm/icside.c: kmalloc + memset conversion to kzalloc
ide: eliminate warnings in ide-tape.c
ide: fix runtogether printk's in cmd64x IDE driver
sis5513: Add FSC Amilo A1630 PCI subvendor/dev to laptops
alim15x3: Correct HP detect
ide: Fix an overrun found in the CS5535 IDE driver
+85
-128
+1
-2
drivers/ide/arm/icside.c
+1
-2
drivers/ide/arm/icside.c
···
693
693
if (ret)
694
694
goto out;
695
695
696
-
state = kmalloc(sizeof(struct icside_state), GFP_KERNEL);
696
+
state = kzalloc(sizeof(struct icside_state), GFP_KERNEL);
697
697
if (!state) {
698
698
ret = -ENOMEM;
699
699
goto release;
700
700
}
701
701
702
-
memset(state, 0, sizeof(state));
703
702
state->type = ICS_TYPE_NOTYPE;
704
703
state->dev = &ec->dev;
705
704
+1
-1
drivers/ide/ide-tape.c
+1
-1
drivers/ide/ide-tape.c
+1
-1
drivers/ide/pci/alim15x3.c
+1
-1
drivers/ide/pci/alim15x3.c
+2
-2
drivers/ide/pci/cmd64x.c
+2
-2
drivers/ide/pci/cmd64x.c
···
475
475
switch (rev) {
476
476
case 0x07:
477
477
case 0x05:
478
-
printk("%s: UltraDMA capable", name);
478
+
printk("%s: UltraDMA capable\n", name);
479
479
break;
480
480
case 0x03:
481
481
default:
482
-
printk("%s: MultiWord DMA force limited", name);
482
+
printk("%s: MultiWord DMA force limited\n", name);
483
483
break;
484
484
case 0x01:
485
485
printk("%s: MultiWord DMA limited, "
+1
-1
drivers/ide/pci/cs5520.c
+1
-1
drivers/ide/pci/cs5520.c
+18
-24
drivers/ide/pci/cs5535.c
+18
-24
drivers/ide/pci/cs5535.c
···
2
2
* linux/drivers/ide/pci/cs5535.c
3
3
*
4
4
* Copyright (C) 2004-2005 Advanced Micro Devices, Inc.
5
+
* Copyright (C) 2007 Bartlomiej Zolnierkiewicz
5
6
*
6
7
* History:
7
8
* 09/20/2005 - Jaya Kumar <jayakumar.ide@gmail.com>
···
84
83
85
84
/* Set the PIO timings */
86
85
if ((speed & XFER_MODE) == XFER_PIO) {
87
-
u8 pioa;
88
-
u8 piob;
89
-
u8 cmd;
86
+
ide_drive_t *pair = &drive->hwif->drives[drive->dn ^ 1];
87
+
u8 cmd, pioa;
90
88
91
-
pioa = speed - XFER_PIO_0;
92
-
piob = ide_get_best_pio_mode(&(drive->hwif->drives[!unit]),
93
-
255, 4);
94
-
cmd = pioa < piob ? pioa : piob;
89
+
cmd = pioa = speed - XFER_PIO_0;
90
+
91
+
if (pair->present) {
92
+
u8 piob = ide_get_best_pio_mode(pair, 255, 4);
93
+
94
+
if (piob < cmd)
95
+
cmd = piob;
96
+
}
95
97
96
98
/* Write the speed of the current drive */
97
99
reg = (cs5535_pio_cmd_timings[cmd] << 16) |
···
120
116
121
117
reg &= 0x80000000UL; /* Preserve the PIO format bit */
122
118
123
-
if (speed >= XFER_UDMA_0 && speed <= XFER_UDMA_7)
119
+
if (speed >= XFER_UDMA_0 && speed <= XFER_UDMA_4)
124
120
reg |= cs5535_udma_timings[speed - XFER_UDMA_0];
125
121
else if (speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2)
126
122
reg |= cs5535_mwdma_timings[speed - XFER_MW_DMA_0];
···
155
151
*
156
152
* A callback from the upper layers for PIO-only tuning.
157
153
*/
158
-
static void cs5535_tuneproc(ide_drive_t *drive, u8 xferspeed)
154
+
static void cs5535_tuneproc(ide_drive_t *drive, u8 pio)
159
155
{
160
-
u8 modes[] = { XFER_PIO_0, XFER_PIO_1, XFER_PIO_2, XFER_PIO_3,
161
-
XFER_PIO_4 };
162
-
163
-
/* cs5535 max pio is pio 4, best_pio will check the blacklist.
164
-
i think we don't need to rate_filter the incoming xferspeed
165
-
since we know we're only going to choose pio */
166
-
xferspeed = ide_get_best_pio_mode(drive, xferspeed, 4);
167
-
ide_config_drive_speed(drive, modes[xferspeed]);
168
-
cs5535_set_speed(drive, xferspeed);
156
+
pio = ide_get_best_pio_mode(drive, pio, 4);
157
+
ide_config_drive_speed(drive, XFER_PIO_0 + pio);
158
+
cs5535_set_speed(drive, XFER_PIO_0 + pio);
169
159
}
170
160
171
161
static int cs5535_dma_check(ide_drive_t *drive)
172
162
{
173
-
u8 speed;
174
-
175
163
drive->init_speed = 0;
176
164
177
165
if (ide_tune_dma(drive))
178
166
return 0;
179
167
180
-
if (ide_use_fast_pio(drive)) {
181
-
speed = ide_get_best_pio_mode(drive, 255, 4);
182
-
cs5535_set_drive(drive, speed);
183
-
}
168
+
if (ide_use_fast_pio(drive))
169
+
cs5535_tuneproc(drive, 255);
184
170
185
171
return -1;
186
172
}
+17
-16
drivers/ide/pci/it8213.c
+17
-16
drivers/ide/pci/it8213.c
···
21
21
* it8213_dma_2_pio - return the PIO mode matching DMA
22
22
* @xfer_rate: transfer speed
23
23
*
24
-
* Returns the nearest equivalent PIO timing for the PIO or DMA
24
+
* Returns the nearest equivalent PIO timing for the DMA
25
25
* mode requested by the controller.
26
26
*/
27
27
···
35
35
case XFER_UDMA_1:
36
36
case XFER_UDMA_0:
37
37
case XFER_MW_DMA_2:
38
-
case XFER_PIO_4:
39
38
return 4;
40
39
case XFER_MW_DMA_1:
41
-
case XFER_PIO_3:
42
40
return 3;
43
41
case XFER_SW_DMA_2:
44
-
case XFER_PIO_2:
45
42
return 2;
46
43
case XFER_MW_DMA_0:
47
44
case XFER_SW_DMA_1:
48
45
case XFER_SW_DMA_0:
49
-
case XFER_PIO_1:
50
-
case XFER_PIO_0:
51
-
case XFER_PIO_SLOW:
52
46
default:
53
47
return 0;
54
48
}
55
49
}
56
50
57
51
/*
58
-
* it8213_tuneproc - tune a drive
52
+
* it8213_tune_pio - tune a drive
59
53
* @drive: drive to tune
60
54
* @pio: desired PIO mode
61
55
*
62
56
* Set the interface PIO mode.
63
57
*/
64
58
65
-
static void it8213_tuneproc (ide_drive_t *drive, u8 pio)
59
+
static void it8213_tune_pio(ide_drive_t *drive, const u8 pio)
66
60
{
67
61
ide_hwif_t *hwif = HWIF(drive);
68
62
struct pci_dev *dev = hwif->pci_dev;
···
75
81
{ 1, 0 },
76
82
{ 2, 1 },
77
83
{ 2, 3 }, };
78
-
79
-
pio = ide_get_best_pio_mode(drive, pio, 4);
80
84
81
85
spin_lock_irqsave(&tune_lock, flags);
82
86
pci_read_config_word(dev, master_port, &master_data);
···
103
111
if (is_slave)
104
112
pci_write_config_byte(dev, slave_port, slave_data);
105
113
spin_unlock_irqrestore(&tune_lock, flags);
114
+
}
115
+
116
+
static void it8213_tuneproc(ide_drive_t *drive, u8 pio)
117
+
{
118
+
pio = ide_get_best_pio_mode(drive, pio, 4);
119
+
it8213_tune_pio(drive, pio);
120
+
ide_config_drive_speed(drive, XFER_PIO_0 + pio);
106
121
}
107
122
108
123
/**
···
192
193
if (reg55 & w_flag)
193
194
pci_write_config_byte(dev, 0x55, (u8) reg55 & ~w_flag);
194
195
}
195
-
it8213_tuneproc(drive, it8213_dma_2_pio(speed));
196
+
197
+
if (speed > XFER_PIO_4)
198
+
it8213_tune_pio(drive, it8213_dma_2_pio(speed));
199
+
else
200
+
it8213_tune_pio(drive, speed - XFER_PIO_0);
201
+
196
202
return ide_config_drive_speed(drive, speed);
197
203
}
198
204
···
213
209
214
210
static int it8213_config_drive_for_dma (ide_drive_t *drive)
215
211
{
216
-
u8 pio;
217
-
218
212
if (ide_tune_dma(drive))
219
213
return 0;
220
214
221
-
pio = ide_get_best_pio_mode(drive, 255, 4);
222
-
it8213_tune_chipset(drive, XFER_PIO_0 + pio);
215
+
it8213_tuneproc(drive, 255);
223
216
224
217
return -1;
225
218
}
+4
-17
drivers/ide/pci/jmicron.c
+4
-17
drivers/ide/pci/jmicron.c
···
83
83
return ATA_CBL_PATA80;
84
84
}
85
85
86
-
static void jmicron_tuneproc (ide_drive_t *drive, byte mode_wanted)
86
+
static void jmicron_tuneproc(ide_drive_t *drive, u8 pio)
87
87
{
88
-
return;
89
-
}
90
-
91
-
/**
92
-
* config_jmicron_chipset_for_pio - set drive timings
93
-
* @drive: drive to tune
94
-
* @speed we want
95
-
*
96
-
*/
97
-
98
-
static void config_jmicron_chipset_for_pio (ide_drive_t *drive, byte set_speed)
99
-
{
100
-
u8 speed = XFER_PIO_0 + ide_get_best_pio_mode(drive, 255, 5);
101
-
if (set_speed)
102
-
(void) ide_config_drive_speed(drive, speed);
88
+
pio = ide_get_best_pio_mode(drive, pio, 5);
89
+
ide_config_drive_speed(drive, XFER_PIO_0 + pio);
103
90
}
104
91
105
92
/**
···
119
132
if (ide_tune_dma(drive))
120
133
return 0;
121
134
122
-
config_jmicron_chipset_for_pio(drive, 1);
135
+
jmicron_tuneproc(drive, 255);
123
136
124
137
return -1;
125
138
}
+8
-9
drivers/ide/pci/piix.c
+8
-9
drivers/ide/pci/piix.c
···
1
1
/*
2
-
* linux/drivers/ide/pci/piix.c Version 0.50 Jun 10, 2007
2
+
* linux/drivers/ide/pci/piix.c Version 0.51 Jul 6, 2007
3
3
*
4
4
* Copyright (C) 1998-1999 Andrzej Krzysztofowicz, Author and Maintainer
5
5
* Copyright (C) 1998-2000 Andre Hedrick <andre@linux-ide.org>
···
109
109
* piix_dma_2_pio - return the PIO mode matching DMA
110
110
* @xfer_rate: transfer speed
111
111
*
112
-
* Returns the nearest equivalent PIO timing for the PIO or DMA
112
+
* Returns the nearest equivalent PIO timing for the DMA
113
113
* mode requested by the controller.
114
114
*/
115
115
···
123
123
case XFER_UDMA_1:
124
124
case XFER_UDMA_0:
125
125
case XFER_MW_DMA_2:
126
-
case XFER_PIO_4:
127
126
return 4;
128
127
case XFER_MW_DMA_1:
129
-
case XFER_PIO_3:
130
128
return 3;
131
129
case XFER_SW_DMA_2:
132
-
case XFER_PIO_2:
133
130
return 2;
134
131
case XFER_MW_DMA_0:
135
132
case XFER_SW_DMA_1:
136
133
case XFER_SW_DMA_0:
137
-
case XFER_PIO_1:
138
-
case XFER_PIO_0:
139
-
case XFER_PIO_SLOW:
140
134
default:
141
135
return 0;
142
136
}
···
263
269
case XFER_PIO_4:
264
270
case XFER_PIO_3:
265
271
case XFER_PIO_2:
272
+
case XFER_PIO_1:
266
273
case XFER_PIO_0: break;
267
274
default: return -1;
268
275
}
···
294
299
pci_write_config_byte(dev, 0x55, (u8) reg55 & ~w_flag);
295
300
}
296
301
297
-
piix_tune_pio(drive, piix_dma_2_pio(speed));
302
+
if (speed > XFER_PIO_4)
303
+
piix_tune_pio(drive, piix_dma_2_pio(speed));
304
+
else
305
+
piix_tune_pio(drive, speed - XFER_PIO_0);
306
+
298
307
return ide_config_drive_speed(drive, speed);
299
308
}
300
309
+20
-41
drivers/ide/pci/scc_pata.c
+20
-41
drivers/ide/pci/scc_pata.c
···
190
190
}
191
191
192
192
/**
193
-
* scc_tuneproc - tune a drive PIO mode
193
+
* scc_tune_pio - tune a drive PIO mode
194
194
* @drive: drive to tune
195
195
* @mode_wanted: the target operating mode
196
196
*
···
198
198
* controller.
199
199
*/
200
200
201
-
static void scc_tuneproc(ide_drive_t *drive, byte mode_wanted)
201
+
static void scc_tune_pio(ide_drive_t *drive, const u8 pio)
202
202
{
203
203
ide_hwif_t *hwif = HWIF(drive);
204
204
struct scc_ports *ports = ide_get_hwifdata(hwif);
···
207
207
unsigned long piosht_port = ctl_base + 0x000;
208
208
unsigned long pioct_port = ctl_base + 0x004;
209
209
unsigned long reg;
210
-
unsigned char speed = XFER_PIO_0;
211
210
int offset;
212
-
213
-
mode_wanted = ide_get_best_pio_mode(drive, mode_wanted, 4);
214
-
switch (mode_wanted) {
215
-
case 4:
216
-
speed = XFER_PIO_4;
217
-
break;
218
-
case 3:
219
-
speed = XFER_PIO_3;
220
-
break;
221
-
case 2:
222
-
speed = XFER_PIO_2;
223
-
break;
224
-
case 1:
225
-
speed = XFER_PIO_1;
226
-
break;
227
-
case 0:
228
-
default:
229
-
speed = XFER_PIO_0;
230
-
break;
231
-
}
232
211
233
212
reg = in_be32((void __iomem *)cckctrl_port);
234
213
if (reg & CCKCTRL_ATACLKOEN) {
···
215
236
} else {
216
237
offset = 0; /* 100MHz */
217
238
}
218
-
reg = JCHSTtbl[offset][mode_wanted] << 16 | JCHHTtbl[offset][mode_wanted];
239
+
reg = JCHSTtbl[offset][pio] << 16 | JCHHTtbl[offset][pio];
219
240
out_be32((void __iomem *)piosht_port, reg);
220
-
reg = JCHCTtbl[offset][mode_wanted];
241
+
reg = JCHCTtbl[offset][pio];
221
242
out_be32((void __iomem *)pioct_port, reg);
243
+
}
222
244
223
-
ide_config_drive_speed(drive, speed);
245
+
static void scc_tuneproc(ide_drive_t *drive, u8 pio)
246
+
{
247
+
pio = ide_get_best_pio_mode(drive, pio, 4);
248
+
scc_tune_pio(drive, pio);
249
+
ide_config_drive_speed(drive, XFER_PIO_0 + pio);
224
250
}
225
251
226
252
/**
···
264
280
265
281
switch (speed) {
266
282
case XFER_UDMA_6:
267
-
idx = 6;
268
-
break;
269
283
case XFER_UDMA_5:
270
-
idx = 5;
271
-
break;
272
284
case XFER_UDMA_4:
273
-
idx = 4;
274
-
break;
275
285
case XFER_UDMA_3:
276
-
idx = 3;
277
-
break;
278
286
case XFER_UDMA_2:
279
-
idx = 2;
280
-
break;
281
287
case XFER_UDMA_1:
282
-
idx = 1;
283
-
break;
284
288
case XFER_UDMA_0:
285
-
idx = 0;
289
+
idx = speed - XFER_UDMA_0;
286
290
break;
291
+
case XFER_PIO_4:
292
+
case XFER_PIO_3:
293
+
case XFER_PIO_2:
294
+
case XFER_PIO_1:
295
+
case XFER_PIO_0:
296
+
scc_tune_pio(drive, speed - XFER_PIO_0);
297
+
return ide_config_drive_speed(drive, speed);
287
298
default:
288
299
return 1;
289
300
}
···
308
329
* required.
309
330
* If the drive isn't suitable for DMA or we hit other problems
310
331
* then we will drop down to PIO and set up PIO appropriately.
311
-
* (return 1)
332
+
* (return -1)
312
333
*/
313
334
314
335
static int scc_config_drive_for_dma(ide_drive_t *drive)
···
317
338
return 0;
318
339
319
340
if (ide_use_fast_pio(drive))
320
-
scc_tuneproc(drive, 4);
341
+
scc_tuneproc(drive, 255);
321
342
322
343
return -1;
323
344
}
+1
drivers/ide/pci/sis5513.c
+1
drivers/ide/pci/sis5513.c
+7
-8
drivers/ide/pci/slc90e66.c
+7
-8
drivers/ide/pci/slc90e66.c
···
1
1
/*
2
-
* linux/drivers/ide/pci/slc90e66.c Version 0.14 February 8, 2007
2
+
* linux/drivers/ide/pci/slc90e66.c Version 0.15 Jul 6, 2007
3
3
*
4
4
* Copyright (C) 2000-2002 Andre Hedrick <andre@linux-ide.org>
5
5
* Copyright (C) 2006-2007 MontaVista Software, Inc. <source@mvista.com>
···
29
29
case XFER_UDMA_1:
30
30
case XFER_UDMA_0:
31
31
case XFER_MW_DMA_2:
32
-
case XFER_PIO_4:
33
32
return 4;
34
33
case XFER_MW_DMA_1:
35
-
case XFER_PIO_3:
36
34
return 3;
37
35
case XFER_SW_DMA_2:
38
-
case XFER_PIO_2:
39
36
return 2;
40
37
case XFER_MW_DMA_0:
41
38
case XFER_SW_DMA_1:
42
39
case XFER_SW_DMA_0:
43
-
case XFER_PIO_1:
44
-
case XFER_PIO_0:
45
-
case XFER_PIO_SLOW:
46
40
default:
47
41
return 0;
48
42
}
···
130
136
case XFER_PIO_4:
131
137
case XFER_PIO_3:
132
138
case XFER_PIO_2:
139
+
case XFER_PIO_1:
133
140
case XFER_PIO_0: break;
134
141
default: return -1;
135
142
}
···
151
156
pci_write_config_word(dev, 0x4a, reg4a & ~a_speed);
152
157
}
153
158
154
-
slc90e66_tune_pio(drive, slc90e66_dma_2_pio(speed));
159
+
if (speed > XFER_PIO_4)
160
+
slc90e66_tune_pio(drive, slc90e66_dma_2_pio(speed));
161
+
else
162
+
slc90e66_tune_pio(drive, speed - XFER_PIO_0);
163
+
155
164
return ide_config_drive_speed(drive, speed);
156
165
}
157
166
+4
-6
drivers/scsi/ide-scsi.c
+4
-6
drivers/scsi/ide-scsi.c
···
328
328
u8 *buf;
329
329
330
330
/* stuff a sense request in front of our current request */
331
-
pc = kmalloc (sizeof (idescsi_pc_t), GFP_ATOMIC);
332
-
rq = kmalloc (sizeof (struct request), GFP_ATOMIC);
333
-
buf = kmalloc(SCSI_SENSE_BUFFERSIZE, GFP_ATOMIC);
334
-
if (pc == NULL || rq == NULL || buf == NULL) {
331
+
pc = kzalloc(sizeof(idescsi_pc_t), GFP_ATOMIC);
332
+
rq = kmalloc(sizeof(struct request), GFP_ATOMIC);
333
+
buf = kzalloc(SCSI_SENSE_BUFFERSIZE, GFP_ATOMIC);
334
+
if (!pc || !rq || !buf) {
335
335
kfree(buf);
336
336
kfree(rq);
337
337
kfree(pc);
338
338
return -ENOMEM;
339
339
}
340
-
memset (pc, 0, sizeof (idescsi_pc_t));
341
-
memset (buf, 0, SCSI_SENSE_BUFFERSIZE);
342
340
ide_init_drive_cmd(rq);
343
341
rq->special = (char *) pc;
344
342
pc->rq = rq;