This source file includes following definitions.
- end_request
1 #ifndef _BLK_H
2 #define _BLK_H
3
4 #include <linux/major.h>
5 #include <linux/sched.h>
6 #include <linux/locks.h>
7 #include <linux/genhd.h>
8
9
10
11
12
13
14
15
16
17
18
19 #define NR_REQUEST 64
20
21
22
23
24
25
26
27 struct request {
28 int dev;
29 int cmd;
30 int errors;
31 unsigned long sector;
32 unsigned long nr_sectors;
33 unsigned long current_nr_sectors;
34 char * buffer;
35 struct semaphore * sem;
36 struct buffer_head * bh;
37 struct buffer_head * bhtail;
38 struct request * next;
39 };
40
41
42
43
44
45
46 #define IN_ORDER(s1,s2) \
47 ((s1)->cmd < (s2)->cmd || ((s1)->cmd == (s2)->cmd && \
48 ((s1)->dev < (s2)->dev || (((s1)->dev == (s2)->dev && \
49 (s1)->sector < (s2)->sector)))))
50
51 struct blk_dev_struct {
52 void (*request_fn)(void);
53 struct request * current_request;
54 };
55
56
57 struct sec_size {
58 unsigned block_size;
59 unsigned block_size_bits;
60 };
61
62
63
64
65
66 #define SECTOR_MASK (blksize_size[MAJOR_NR] && \
67 blksize_size[MAJOR_NR][MINOR(CURRENT->dev)] ? \
68 ((blksize_size[MAJOR_NR][MINOR(CURRENT->dev)] >> 9) - 1) : \
69 ((BLOCK_SIZE >> 9) - 1))
70
71 #define SUBSECTOR(block) (CURRENT->current_nr_sectors > 0)
72
73 extern struct sec_size * blk_sec[MAX_BLKDEV];
74 extern struct blk_dev_struct blk_dev[MAX_BLKDEV];
75 extern struct wait_queue * wait_for_request;
76 extern void resetup_one_dev(struct gendisk *dev, int drive);
77
78 extern int * blk_size[MAX_BLKDEV];
79
80 extern int * blksize_size[MAX_BLKDEV];
81
82 extern unsigned long hd_init(unsigned long mem_start, unsigned long mem_end);
83 extern unsigned long cdu31a_init(unsigned long mem_start, unsigned long mem_end);
84 extern unsigned long mcd_init(unsigned long mem_start, unsigned long mem_end);
85 #ifdef CONFIG_SBPCD
86 extern unsigned long sbpcd_init(unsigned long, unsigned long);
87 #endif CONFIG_SBPCD
88 extern void set_device_ro(int dev,int flag);
89
90 extern void rd_load(void);
91 extern long rd_init(long mem_start, int length);
92 extern int ramdisk_size;
93
94 extern unsigned long xd_init(unsigned long mem_start, unsigned long mem_end);
95
96 #define RO_IOCTLS(dev,where) \
97 case BLKROSET: if (!suser()) return -EACCES; \
98 set_device_ro((dev),get_fs_long((long *) (where))); return 0; \
99 case BLKROGET: { int __err = verify_area(VERIFY_WRITE, (void *) (where), sizeof(long)); \
100 if (!__err) put_fs_long(0!=is_read_only(dev),(long *) (where)); return __err; }
101
102 #ifdef MAJOR_NR
103
104
105
106
107
108
109 #if (MAJOR_NR == MEM_MAJOR)
110
111
112 #define DEVICE_NAME "ramdisk"
113 #define DEVICE_REQUEST do_rd_request
114 #define DEVICE_NR(device) ((device) & 7)
115 #define DEVICE_ON(device)
116 #define DEVICE_OFF(device)
117
118 #elif (MAJOR_NR == FLOPPY_MAJOR)
119
120 static void floppy_on(unsigned int nr);
121 static void floppy_off(unsigned int nr);
122
123 #define DEVICE_NAME "floppy"
124 #define DEVICE_INTR do_floppy
125 #define DEVICE_REQUEST do_fd_request
126 #define DEVICE_NR(device) ( ((device) & 3) | (((device) & 0x80 ) >> 5 ))
127 #define DEVICE_ON(device) floppy_on(DEVICE_NR(device))
128 #define DEVICE_OFF(device) floppy_off(DEVICE_NR(device))
129
130 #elif (MAJOR_NR == HD_MAJOR)
131
132
133 #define DEVICE_NAME "harddisk"
134 #define DEVICE_INTR do_hd
135 #define DEVICE_TIMEOUT HD_TIMER
136 #define TIMEOUT_VALUE 600
137 #define DEVICE_REQUEST do_hd_request
138 #define DEVICE_NR(device) (MINOR(device)>>6)
139 #define DEVICE_ON(device)
140 #define DEVICE_OFF(device)
141
142 #elif (MAJOR_NR == SCSI_DISK_MAJOR)
143
144 #define DEVICE_NAME "scsidisk"
145 #define DEVICE_INTR do_sd
146 #define TIMEOUT_VALUE 200
147 #define DEVICE_REQUEST do_sd_request
148 #define DEVICE_NR(device) (MINOR(device) >> 4)
149 #define DEVICE_ON(device)
150 #define DEVICE_OFF(device)
151
152 #elif (MAJOR_NR == SCSI_TAPE_MAJOR)
153
154 #define DEVICE_NAME "scsitape"
155 #define DEVICE_INTR do_st
156 #define DEVICE_NR(device) (MINOR(device))
157 #define DEVICE_ON(device)
158 #define DEVICE_OFF(device)
159
160 #elif (MAJOR_NR == SCSI_CDROM_MAJOR)
161
162 #define DEVICE_NAME "CD-ROM"
163 #define DEVICE_INTR do_sr
164 #define DEVICE_REQUEST do_sr_request
165 #define DEVICE_NR(device) (MINOR(device))
166 #define DEVICE_ON(device)
167 #define DEVICE_OFF(device)
168
169 #elif (MAJOR_NR == XT_DISK_MAJOR)
170
171 #define DEVICE_NAME "xt disk"
172 #define DEVICE_REQUEST do_xd_request
173 #define DEVICE_NR(device) (MINOR(device) >> 6)
174 #define DEVICE_ON(device)
175 #define DEVICE_OFF(device)
176
177 #elif (MAJOR_NR == CDU31A_CDROM_MAJOR)
178
179 #define DEVICE_NAME "CDU31A"
180 #define DEVICE_REQUEST do_cdu31a_request
181 #define DEVICE_NR(device) (MINOR(device))
182 #define DEVICE_ON(device)
183 #define DEVICE_OFF(device)
184
185 #elif (MAJOR_NR == MITSUMI_CDROM_MAJOR)
186
187 #define DEVICE_NAME "Mitsumi CD-ROM"
188
189 #define DEVICE_REQUEST do_mcd_request
190 #define DEVICE_NR(device) (MINOR(device))
191 #define DEVICE_ON(device)
192 #define DEVICE_OFF(device)
193
194 #elif (MAJOR_NR == MATSUSHITA_CDROM_MAJOR)
195
196 #define DEVICE_NAME "Matsushita CD-ROM controller #1"
197 #define DEVICE_REQUEST do_sbpcd_request
198 #define DEVICE_NR(device) (MINOR(device))
199 #define DEVICE_ON(device)
200 #define DEVICE_OFF(device)
201
202 #elif (MAJOR_NR == MATSUSHITA_CDROM2_MAJOR)
203
204 #define DEVICE_NAME "Matsushita CD-ROM controller #2"
205 #define DEVICE_REQUEST do_sbpcd2_request
206 #define DEVICE_NR(device) (MINOR(device))
207 #define DEVICE_ON(device)
208 #define DEVICE_OFF(device)
209
210 #elif (MAJOR_NR == MATSUSHITA_CDROM3_MAJOR)
211
212 #define DEVICE_NAME "Matsushita CD-ROM controller #3"
213 #define DEVICE_REQUEST do_sbpcd3_request
214 #define DEVICE_NR(device) (MINOR(device))
215 #define DEVICE_ON(device)
216 #define DEVICE_OFF(device)
217
218 #elif (MAJOR_NR == MATSUSHITA_CDROM4_MAJOR)
219
220 #define DEVICE_NAME "Matsushita CD-ROM controller #4"
221 #define DEVICE_REQUEST do_sbpcd4_request
222 #define DEVICE_NR(device) (MINOR(device))
223 #define DEVICE_ON(device)
224 #define DEVICE_OFF(device)
225
226 #else
227
228 #error "unknown blk device"
229
230 #endif
231
232 #if (MAJOR_NR != SCSI_TAPE_MAJOR)
233
234 #ifndef CURRENT
235 #define CURRENT (blk_dev[MAJOR_NR].current_request)
236 #endif
237
238 #define CURRENT_DEV DEVICE_NR(CURRENT->dev)
239
240 #ifdef DEVICE_INTR
241 void (*DEVICE_INTR)(void) = NULL;
242 #endif
243 #ifdef DEVICE_TIMEOUT
244
245 #define SET_TIMER \
246 ((timer_table[DEVICE_TIMEOUT].expires = jiffies + TIMEOUT_VALUE), \
247 (timer_active |= 1<<DEVICE_TIMEOUT))
248
249 #define CLEAR_TIMER \
250 timer_active &= ~(1<<DEVICE_TIMEOUT)
251
252 #define SET_INTR(x) \
253 if ((DEVICE_INTR = (x)) != NULL) \
254 SET_TIMER; \
255 else \
256 CLEAR_TIMER;
257
258 #else
259
260 #define SET_INTR(x) (DEVICE_INTR = (x))
261
262 #endif
263 static void (DEVICE_REQUEST)(void);
264
265
266
267 #if ! SCSI_MAJOR(MAJOR_NR)
268
269 static void end_request(int uptodate)
270 {
271 struct request * req;
272 struct buffer_head * bh;
273
274 req = CURRENT;
275 req->errors = 0;
276 if (!uptodate) {
277 printk(DEVICE_NAME " I/O error\n");
278 printk("dev %04lX, sector %lu\n",
279 (unsigned long)req->dev, req->sector);
280 req->nr_sectors--;
281 req->nr_sectors &= ~SECTOR_MASK;
282 req->sector += (BLOCK_SIZE / 512);
283 req->sector &= ~SECTOR_MASK;
284 }
285
286 if ((bh = req->bh) != NULL) {
287 req->bh = bh->b_reqnext;
288 bh->b_reqnext = NULL;
289 bh->b_uptodate = uptodate;
290 if (!uptodate) bh->b_req = 0;
291 unlock_buffer(bh);
292 if ((bh = req->bh) != NULL) {
293 req->current_nr_sectors = bh->b_size >> 9;
294 if (req->nr_sectors < req->current_nr_sectors) {
295 req->nr_sectors = req->current_nr_sectors;
296 printk("end_request: buffer-list destroyed\n");
297 }
298 req->buffer = bh->b_data;
299 return;
300 }
301 }
302 DEVICE_OFF(req->dev);
303 CURRENT = req->next;
304 if (req->sem != NULL)
305 up(req->sem);
306 req->dev = -1;
307 wake_up(&wait_for_request);
308 }
309 #endif
310
311 #ifdef DEVICE_INTR
312 #define CLEAR_INTR SET_INTR(NULL)
313 #else
314 #define CLEAR_INTR
315 #endif
316
317 #define INIT_REQUEST \
318 if (!CURRENT) {\
319 CLEAR_INTR; \
320 return; \
321 } \
322 if (MAJOR(CURRENT->dev) != MAJOR_NR) \
323 panic(DEVICE_NAME ": request list destroyed"); \
324 if (CURRENT->bh) { \
325 if (!CURRENT->bh->b_lock) \
326 panic(DEVICE_NAME ": block not locked"); \
327 }
328
329 #endif
330
331 #endif
332 #endif