Diff markup
1 /* 1 /*
>> 2 * linux/drivers/ide/legacy/ali14xx.c Version 0.03 Feb 09, 1996
>> 3 *
2 * Copyright (C) 1996 Linus Torvalds & autho 4 * Copyright (C) 1996 Linus Torvalds & author (see below)
3 */ 5 */
4 6
5 /* 7 /*
6 * ALI M14xx chipset EIDE controller 8 * ALI M14xx chipset EIDE controller
7 * 9 *
8 * Works for ALI M1439/1443/1445/1487/1489 chi 10 * Works for ALI M1439/1443/1445/1487/1489 chipsets.
9 * 11 *
10 * Adapted from code developed by derekn@vw.ec 12 * Adapted from code developed by derekn@vw.ece.cmu.edu. -ml
11 * Derek's notes follow: 13 * Derek's notes follow:
12 * 14 *
13 * I think the code should be pretty understan 15 * I think the code should be pretty understandable,
14 * but I'll be happy to (try to) answer questi 16 * but I'll be happy to (try to) answer questions.
15 * 17 *
16 * The critical part is in the setupDrive func 18 * The critical part is in the setupDrive function. The initRegisters
17 * function doesn't seem to be necessary, but 19 * function doesn't seem to be necessary, but the DOS driver does it, so
18 * I threw it in. 20 * I threw it in.
19 * 21 *
20 * I've only tested this on my system, which o 22 * I've only tested this on my system, which only has one disk. I posted
21 * it to comp.sys.linux.hardware, so maybe som 23 * it to comp.sys.linux.hardware, so maybe some other people will try it
22 * out. 24 * out.
23 * 25 *
24 * Derek Noonburg (derekn@ece.cmu.edu) 26 * Derek Noonburg (derekn@ece.cmu.edu)
25 * 95-sep-26 27 * 95-sep-26
26 * 28 *
27 * Update 96-jul-13: 29 * Update 96-jul-13:
28 * 30 *
29 * I've since upgraded to two disks and a CD-R 31 * I've since upgraded to two disks and a CD-ROM, with no trouble, and
30 * I've also heard from several others who hav 32 * I've also heard from several others who have used it successfully.
31 * This driver appears to work with both the 1 33 * This driver appears to work with both the 1443/1445 and the 1487/1489
32 * chipsets. I've added support for PIO mode 34 * chipsets. I've added support for PIO mode 4 for the 1487. This
33 * seems to work just fine on the 1443 also, a 35 * seems to work just fine on the 1443 also, although I'm not sure it's
34 * advertised as supporting mode 4. (I've bee 36 * advertised as supporting mode 4. (I've been running a WDC AC21200 in
35 * mode 4 for a while now with no trouble.) - 37 * mode 4 for a while now with no trouble.) -Derek
36 */ 38 */
37 39
>> 40 #undef REALLY_SLOW_IO /* most systems can safely undef this */
>> 41
38 #include <linux/module.h> 42 #include <linux/module.h>
>> 43 #include <linux/config.h>
39 #include <linux/types.h> 44 #include <linux/types.h>
40 #include <linux/kernel.h> 45 #include <linux/kernel.h>
41 #include <linux/delay.h> 46 #include <linux/delay.h>
42 #include <linux/timer.h> 47 #include <linux/timer.h>
43 #include <linux/mm.h> 48 #include <linux/mm.h>
44 #include <linux/ioport.h> 49 #include <linux/ioport.h>
45 #include <linux/blkdev.h> 50 #include <linux/blkdev.h>
46 #include <linux/hdreg.h> 51 #include <linux/hdreg.h>
47 #include <linux/ide.h> 52 #include <linux/ide.h>
48 #include <linux/init.h> 53 #include <linux/init.h>
49 54
50 #include <asm/io.h> 55 #include <asm/io.h>
51 56
52 /* port addresses for auto-detection */ 57 /* port addresses for auto-detection */
53 #define ALI_NUM_PORTS 4 58 #define ALI_NUM_PORTS 4
54 static const int ports[ALI_NUM_PORTS] __initda !! 59 static int ports[ALI_NUM_PORTS] __initdata = {0x074, 0x0f4, 0x034, 0x0e4};
55 { 0x074, 0x0f4, 0x034, 0x0e4 }; <<
56 60
57 /* register initialization data */ 61 /* register initialization data */
58 typedef struct { u8 reg, data; } RegInitialize 62 typedef struct { u8 reg, data; } RegInitializer;
59 63
60 static const RegInitializer initData[] __initd !! 64 static RegInitializer initData[] __initdata = {
61 {0x01, 0x0f}, {0x02, 0x00}, {0x03, 0x0 65 {0x01, 0x0f}, {0x02, 0x00}, {0x03, 0x00}, {0x04, 0x00},
62 {0x05, 0x00}, {0x06, 0x00}, {0x07, 0x2 66 {0x05, 0x00}, {0x06, 0x00}, {0x07, 0x2b}, {0x0a, 0x0f},
63 {0x25, 0x00}, {0x26, 0x00}, {0x27, 0x0 67 {0x25, 0x00}, {0x26, 0x00}, {0x27, 0x00}, {0x28, 0x00},
64 {0x29, 0x00}, {0x2a, 0x00}, {0x2f, 0x0 68 {0x29, 0x00}, {0x2a, 0x00}, {0x2f, 0x00}, {0x2b, 0x00},
65 {0x2c, 0x00}, {0x2d, 0x00}, {0x2e, 0x0 69 {0x2c, 0x00}, {0x2d, 0x00}, {0x2e, 0x00}, {0x30, 0x00},
66 {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x0 70 {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00}, {0x34, 0xff},
67 {0x35, 0x03}, {0x00, 0x00} 71 {0x35, 0x03}, {0x00, 0x00}
68 }; 72 };
69 73
>> 74 #define ALI_MAX_PIO 4
>> 75
70 /* timing parameter registers for each drive * 76 /* timing parameter registers for each drive */
71 static struct { u8 reg1, reg2, reg3, reg4; } r 77 static struct { u8 reg1, reg2, reg3, reg4; } regTab[4] = {
72 {0x03, 0x26, 0x04, 0x27}, /* drive 78 {0x03, 0x26, 0x04, 0x27}, /* drive 0 */
73 {0x05, 0x28, 0x06, 0x29}, /* drive 79 {0x05, 0x28, 0x06, 0x29}, /* drive 1 */
74 {0x2b, 0x30, 0x2c, 0x31}, /* drive 80 {0x2b, 0x30, 0x2c, 0x31}, /* drive 2 */
75 {0x2d, 0x32, 0x2e, 0x33}, /* drive 81 {0x2d, 0x32, 0x2e, 0x33}, /* drive 3 */
76 }; 82 };
77 83
78 static int basePort; /* base port address * 84 static int basePort; /* base port address */
79 static int regPort; /* port for register n 85 static int regPort; /* port for register number */
80 static int dataPort; /* port for register d 86 static int dataPort; /* port for register data */
81 static u8 regOn; /* output to base port 87 static u8 regOn; /* output to base port to access registers */
82 static u8 regOff; /* output to base port 88 static u8 regOff; /* output to base port to close registers */
83 89
84 /*-------------------------------------------- 90 /*------------------------------------------------------------------------*/
85 91
86 /* 92 /*
87 * Read a controller register. 93 * Read a controller register.
88 */ 94 */
89 static inline u8 inReg (u8 reg) 95 static inline u8 inReg (u8 reg)
90 { 96 {
91 outb_p(reg, regPort); 97 outb_p(reg, regPort);
92 return inb(dataPort); 98 return inb(dataPort);
93 } 99 }
94 100
95 /* 101 /*
96 * Write a controller register. 102 * Write a controller register.
97 */ 103 */
98 static void outReg (u8 data, u8 reg) 104 static void outReg (u8 data, u8 reg)
99 { 105 {
100 outb_p(reg, regPort); 106 outb_p(reg, regPort);
101 outb_p(data, dataPort); 107 outb_p(data, dataPort);
102 } 108 }
103 109
104 static DEFINE_SPINLOCK(ali14xx_lock); <<
105 <<
106 /* 110 /*
107 * Set PIO mode for the specified drive. 111 * Set PIO mode for the specified drive.
108 * This function computes timing parameters 112 * This function computes timing parameters
109 * and sets controller registers accordingly. 113 * and sets controller registers accordingly.
110 */ 114 */
111 static void ali14xx_set_pio_mode(ide_drive_t * !! 115 static void ali14xx_tune_drive (ide_drive_t *drive, u8 pio)
112 { 116 {
113 int driveNum; 117 int driveNum;
114 int time1, time2; 118 int time1, time2;
115 u8 param1, param2, param3, param4; 119 u8 param1, param2, param3, param4;
116 unsigned long flags; 120 unsigned long flags;
>> 121 ide_pio_data_t d;
117 int bus_speed = system_bus_clock(); 122 int bus_speed = system_bus_clock();
118 123
>> 124 pio = ide_get_best_pio_mode(drive, pio, ALI_MAX_PIO, &d);
>> 125
119 /* calculate timing, according to PIO 126 /* calculate timing, according to PIO mode */
120 time1 = ide_pio_cycle_time(drive, pio) !! 127 time1 = d.cycle_time;
121 time2 = ide_pio_timings[pio].active_ti 128 time2 = ide_pio_timings[pio].active_time;
122 param3 = param1 = (time2 * bus_speed + 129 param3 = param1 = (time2 * bus_speed + 999) / 1000;
123 param4 = param2 = (time1 * bus_speed + 130 param4 = param2 = (time1 * bus_speed + 999) / 1000 - param1;
124 if (pio < 3) { 131 if (pio < 3) {
125 param3 += 8; 132 param3 += 8;
126 param4 += 8; 133 param4 += 8;
127 } 134 }
128 printk(KERN_DEBUG "%s: PIO mode%d, t1= 135 printk(KERN_DEBUG "%s: PIO mode%d, t1=%dns, t2=%dns, cycles = %d+%d, %d+%d\n",
129 drive->name, pio, time1, time2 136 drive->name, pio, time1, time2, param1, param2, param3, param4);
130 137
131 /* stuff timing parameters into contro 138 /* stuff timing parameters into controller registers */
132 driveNum = (HWIF(drive)->index << 1) + 139 driveNum = (HWIF(drive)->index << 1) + drive->select.b.unit;
133 spin_lock_irqsave(&ali14xx_lock, flags !! 140 spin_lock_irqsave(&ide_lock, flags);
134 outb_p(regOn, basePort); 141 outb_p(regOn, basePort);
135 outReg(param1, regTab[driveNum].reg1); 142 outReg(param1, regTab[driveNum].reg1);
136 outReg(param2, regTab[driveNum].reg2); 143 outReg(param2, regTab[driveNum].reg2);
137 outReg(param3, regTab[driveNum].reg3); 144 outReg(param3, regTab[driveNum].reg3);
138 outReg(param4, regTab[driveNum].reg4); 145 outReg(param4, regTab[driveNum].reg4);
139 outb_p(regOff, basePort); 146 outb_p(regOff, basePort);
140 spin_unlock_irqrestore(&ali14xx_lock, !! 147 spin_unlock_irqrestore(&ide_lock, flags);
141 } 148 }
142 149
143 /* 150 /*
144 * Auto-detect the IDE controller port. 151 * Auto-detect the IDE controller port.
145 */ 152 */
146 static int __init findPort (void) 153 static int __init findPort (void)
147 { 154 {
148 int i; 155 int i;
149 u8 t; 156 u8 t;
150 unsigned long flags; 157 unsigned long flags;
151 158
152 local_irq_save(flags); 159 local_irq_save(flags);
153 for (i = 0; i < ALI_NUM_PORTS; ++i) { 160 for (i = 0; i < ALI_NUM_PORTS; ++i) {
154 basePort = ports[i]; 161 basePort = ports[i];
155 regOff = inb(basePort); 162 regOff = inb(basePort);
156 for (regOn = 0x30; regOn <= 0x 163 for (regOn = 0x30; regOn <= 0x33; ++regOn) {
157 outb_p(regOn, basePort 164 outb_p(regOn, basePort);
158 if (inb(basePort) == r 165 if (inb(basePort) == regOn) {
159 regPort = base 166 regPort = basePort + 4;
160 dataPort = bas 167 dataPort = basePort + 8;
161 t = inReg(0) & 168 t = inReg(0) & 0xf0;
162 outb_p(regOff, 169 outb_p(regOff, basePort);
163 local_irq_rest 170 local_irq_restore(flags);
164 if (t != 0x50) 171 if (t != 0x50)
165 return 172 return 0;
166 return 1; /* 173 return 1; /* success */
167 } 174 }
168 } 175 }
169 outb_p(regOff, basePort); 176 outb_p(regOff, basePort);
170 } 177 }
171 local_irq_restore(flags); 178 local_irq_restore(flags);
172 return 0; 179 return 0;
173 } 180 }
174 181
175 /* 182 /*
176 * Initialize controller registers with defaul 183 * Initialize controller registers with default values.
177 */ 184 */
178 static int __init initRegisters (void) { 185 static int __init initRegisters (void) {
179 const RegInitializer *p; !! 186 RegInitializer *p;
180 u8 t; 187 u8 t;
181 unsigned long flags; 188 unsigned long flags;
182 189
183 local_irq_save(flags); 190 local_irq_save(flags);
184 outb_p(regOn, basePort); 191 outb_p(regOn, basePort);
185 for (p = initData; p->reg != 0; ++p) 192 for (p = initData; p->reg != 0; ++p)
186 outReg(p->data, p->reg); 193 outReg(p->data, p->reg);
187 outb_p(0x01, regPort); 194 outb_p(0x01, regPort);
188 t = inb(regPort) & 0x01; 195 t = inb(regPort) & 0x01;
189 outb_p(regOff, basePort); 196 outb_p(regOff, basePort);
190 local_irq_restore(flags); 197 local_irq_restore(flags);
191 return t; 198 return t;
192 } 199 }
193 200
194 static const struct ide_port_info ali14xx_port <<
195 .chipset = ide_ali14xx, <<
196 .host_flags = IDE_HFLAG_NO <<
197 .pio_mask = ATA_PIO4, <<
198 }; <<
199 <<
200 static int __init ali14xx_probe(void) 201 static int __init ali14xx_probe(void)
201 { 202 {
202 static u8 idx[4] = { 0, 1, 0xff, 0xff !! 203 ide_hwif_t *hwif, *mate;
203 204
204 printk(KERN_DEBUG "ali14xx: base=0x%03 205 printk(KERN_DEBUG "ali14xx: base=0x%03x, regOn=0x%02x.\n",
205 basePort, regOn); 206 basePort, regOn);
206 207
207 /* initialize controller registers */ 208 /* initialize controller registers */
208 if (!initRegisters()) { 209 if (!initRegisters()) {
209 printk(KERN_ERR "ali14xx: Chip 210 printk(KERN_ERR "ali14xx: Chip initialization failed.\n");
210 return 1; 211 return 1;
211 } 212 }
212 213
213 ide_hwifs[0].set_pio_mode = &ali14xx_s !! 214 hwif = &ide_hwifs[0];
214 ide_hwifs[1].set_pio_mode = &ali14xx_s !! 215 mate = &ide_hwifs[1];
215 216
216 ide_device_add(idx, &ali14xx_port_info !! 217 hwif->chipset = ide_ali14xx;
>> 218 hwif->tuneproc = &ali14xx_tune_drive;
>> 219 hwif->mate = mate;
>> 220
>> 221 mate->chipset = ide_ali14xx;
>> 222 mate->tuneproc = &ali14xx_tune_drive;
>> 223 mate->mate = hwif;
>> 224 mate->channel = 1;
217 225
218 return 0; !! 226 probe_hwif_init(hwif);
219 } !! 227 probe_hwif_init(mate);
220 228
221 int probe_ali14xx = 0; !! 229 create_proc_ide_interfaces();
222 230
223 module_param_named(probe, probe_ali14xx, bool, !! 231 return 0;
224 MODULE_PARM_DESC(probe, "probe for ALI M14xx c !! 232 }
225 233
226 static int __init ali14xx_init(void) !! 234 /* Can be called directly from ide.c. */
>> 235 int __init ali14xx_init(void)
227 { 236 {
228 if (probe_ali14xx == 0) <<
229 goto out; <<
230 <<
231 /* auto-detect IDE controller port */ 237 /* auto-detect IDE controller port */
232 if (findPort()) { 238 if (findPort()) {
233 if (ali14xx_probe()) 239 if (ali14xx_probe())
234 return -ENODEV; 240 return -ENODEV;
235 return 0; 241 return 0;
236 } 242 }
237 printk(KERN_ERR "ali14xx: not found.\n 243 printk(KERN_ERR "ali14xx: not found.\n");
238 out: <<
239 return -ENODEV; 244 return -ENODEV;
240 } 245 }
241 246
>> 247 #ifdef MODULE
242 module_init(ali14xx_init); 248 module_init(ali14xx_init);
>> 249 #endif
243 250
244 MODULE_AUTHOR("see local file"); 251 MODULE_AUTHOR("see local file");
245 MODULE_DESCRIPTION("support of ALI 14XX IDE ch 252 MODULE_DESCRIPTION("support of ALI 14XX IDE chipsets");
246 MODULE_LICENSE("GPL"); 253 MODULE_LICENSE("GPL");
247 254
|
This page was automatically generated by the
LXR engine.
|