]> nv-tegra.nvidia Code Review - linux-2.6.git/blob - drivers/message/i2o/i2o_block.c
4830b775906104d718b882c720a3ea1d306b96f3
[linux-2.6.git] / drivers / message / i2o / i2o_block.c
1 /*
2  *      Block OSM
3  *
4  *      Copyright (C) 1999-2002 Red Hat Software
5  *
6  *      Written by Alan Cox, Building Number Three Ltd
7  *
8  *      This program is free software; you can redistribute it and/or modify it
9  *      under the terms of the GNU General Public License as published by the
10  *      Free Software Foundation; either version 2 of the License, or (at your
11  *      option) any later version.
12  *
13  *      This program is distributed in the hope that it will be useful, but
14  *      WITHOUT ANY WARRANTY; without even the implied warranty of
15  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  *      General Public License for more details.
17  *
18  *      For the purpose of avoiding doubt the preferred form of the work
19  *      for making modifications shall be a standards compliant form such
20  *      gzipped tar and not one requiring a proprietary or patent encumbered
21  *      tool to unpack.
22  *
23  *      Fixes/additions:
24  *              Steve Ralston:
25  *                      Multiple device handling error fixes,
26  *                      Added a queue depth.
27  *              Alan Cox:
28  *                      FC920 has an rmw bug. Dont or in the end marker.
29  *                      Removed queue walk, fixed for 64bitness.
30  *                      Rewrote much of the code over time
31  *                      Added indirect block lists
32  *                      Handle 64K limits on many controllers
33  *                      Don't use indirects on the Promise (breaks)
34  *                      Heavily chop down the queue depths
35  *              Deepak Saxena:
36  *                      Independent queues per IOP
37  *                      Support for dynamic device creation/deletion
38  *                      Code cleanup
39  *                      Support for larger I/Os through merge* functions
40  *                      (taken from DAC960 driver)
41  *              Boji T Kannanthanam:
42  *                      Set the I2O Block devices to be detected in increasing
43  *                      order of TIDs during boot.
44  *                      Search and set the I2O block device that we boot off
45  *                      from as the first device to be claimed (as /dev/i2o/hda)
46  *                      Properly attach/detach I2O gendisk structure from the
47  *                      system gendisk list. The I2O block devices now appear in
48  *                      /proc/partitions.
49  *              Markus Lidel <Markus.Lidel@shadowconnect.com>:
50  *                      Minor bugfixes for 2.6.
51  */
52
53 #include <linux/module.h>
54 #include <linux/i2o.h>
55
56 #include <linux/mempool.h>
57
58 #include <linux/genhd.h>
59 #include <linux/blkdev.h>
60 #include <linux/hdreg.h>
61
62 #include "i2o_block.h"
63
64 #define OSM_NAME        "block-osm"
65 #define OSM_VERSION     "$Rev$"
66 #define OSM_DESCRIPTION "I2O Block Device OSM"
67
68 static struct i2o_driver i2o_block_driver;
69
70 /* global Block OSM request mempool */
71 static struct i2o_block_mempool i2o_blk_req_pool;
72
73 /* Block OSM class handling definition */
74 static struct i2o_class_id i2o_block_class_id[] = {
75         {I2O_CLASS_RANDOM_BLOCK_STORAGE},
76         {I2O_CLASS_END}
77 };
78
79 /**
80  *      i2o_block_device_free - free the memory of the I2O Block device
81  *      @dev: I2O Block device, which should be cleaned up
82  *
83  *      Frees the request queue, gendisk and the i2o_block_device structure.
84  */
85 static void i2o_block_device_free(struct i2o_block_device *dev)
86 {
87         blk_cleanup_queue(dev->gd->queue);
88
89         put_disk(dev->gd);
90
91         kfree(dev);
92 };
93
94 /**
95  *      i2o_block_remove - remove the I2O Block device from the system again
96  *      @dev: I2O Block device which should be removed
97  *
98  *      Remove gendisk from system and free all allocated memory.
99  *
100  *      Always returns 0.
101  */
102 static int i2o_block_remove(struct device *dev)
103 {
104         struct i2o_device *i2o_dev = to_i2o_device(dev);
105         struct i2o_block_device *i2o_blk_dev = dev_get_drvdata(dev);
106
107         osm_info("Device removed %s\n", i2o_blk_dev->gd->disk_name);
108
109         i2o_event_register(i2o_dev, &i2o_block_driver, 0, 0);
110
111         del_gendisk(i2o_blk_dev->gd);
112
113         dev_set_drvdata(dev, NULL);
114
115         i2o_device_claim_release(i2o_dev);
116
117         i2o_block_device_free(i2o_blk_dev);
118
119         return 0;
120 };
121
122 /**
123  *      i2o_block_device flush - Flush all dirty data of I2O device dev
124  *      @dev: I2O device which should be flushed
125  *
126  *      Flushes all dirty data on device dev.
127  *
128  *      Returns 0 on success or negative error code on failure.
129  */
130 static int i2o_block_device_flush(struct i2o_device *dev)
131 {
132         struct i2o_message __iomem *msg;
133         u32 m;
134
135         m = i2o_msg_get_wait(dev->iop, &msg, I2O_TIMEOUT_MESSAGE_GET);
136         if (m == I2O_QUEUE_EMPTY)
137                 return -ETIMEDOUT;
138
139         writel(FIVE_WORD_MSG_SIZE | SGL_OFFSET_0, &msg->u.head[0]);
140         writel(I2O_CMD_BLOCK_CFLUSH << 24 | HOST_TID << 12 | dev->lct_data.tid,
141                &msg->u.head[1]);
142         writel(60 << 16, &msg->body[0]);
143         osm_debug("Flushing...\n");
144
145         return i2o_msg_post_wait(dev->iop, m, 60);
146 };
147
148 /**
149  *      i2o_block_device_mount - Mount (load) the media of device dev
150  *      @dev: I2O device which should receive the mount request
151  *      @media_id: Media Identifier
152  *
153  *      Load a media into drive. Identifier should be set to -1, because the
154  *      spec does not support any other value.
155  *
156  *      Returns 0 on success or negative error code on failure.
157  */
158 static int i2o_block_device_mount(struct i2o_device *dev, u32 media_id)
159 {
160         struct i2o_message __iomem *msg;
161         u32 m;
162
163         m = i2o_msg_get_wait(dev->iop, &msg, I2O_TIMEOUT_MESSAGE_GET);
164         if (m == I2O_QUEUE_EMPTY)
165                 return -ETIMEDOUT;
166
167         writel(FIVE_WORD_MSG_SIZE | SGL_OFFSET_0, &msg->u.head[0]);
168         writel(I2O_CMD_BLOCK_MMOUNT << 24 | HOST_TID << 12 | dev->lct_data.tid,
169                &msg->u.head[1]);
170         writel(-1, &msg->body[0]);
171         writel(0, &msg->body[1]);
172         osm_debug("Mounting...\n");
173
174         return i2o_msg_post_wait(dev->iop, m, 2);
175 };
176
177 /**
178  *      i2o_block_device_lock - Locks the media of device dev
179  *      @dev: I2O device which should receive the lock request
180  *      @media_id: Media Identifier
181  *
182  *      Lock media of device dev to prevent removal. The media identifier
183  *      should be set to -1, because the spec does not support any other value.
184  *
185  *      Returns 0 on success or negative error code on failure.
186  */
187 static int i2o_block_device_lock(struct i2o_device *dev, u32 media_id)
188 {
189         struct i2o_message __iomem *msg;
190         u32 m;
191
192         m = i2o_msg_get_wait(dev->iop, &msg, I2O_TIMEOUT_MESSAGE_GET);
193         if (m == I2O_QUEUE_EMPTY)
194                 return -ETIMEDOUT;
195
196         writel(FIVE_WORD_MSG_SIZE | SGL_OFFSET_0, &msg->u.head[0]);
197         writel(I2O_CMD_BLOCK_MLOCK << 24 | HOST_TID << 12 | dev->lct_data.tid,
198                &msg->u.head[1]);
199         writel(-1, &msg->body[0]);
200         osm_debug("Locking...\n");
201
202         return i2o_msg_post_wait(dev->iop, m, 2);
203 };
204
205 /**
206  *      i2o_block_device_unlock - Unlocks the media of device dev
207  *      @dev: I2O device which should receive the unlocked request
208  *      @media_id: Media Identifier
209  *
210  *      Unlocks the media in device dev. The media identifier should be set to
211  *      -1, because the spec does not support any other value.
212  *
213  *      Returns 0 on success or negative error code on failure.
214  */
215 static int i2o_block_device_unlock(struct i2o_device *dev, u32 media_id)
216 {
217         struct i2o_message __iomem *msg;
218         u32 m;
219
220         m = i2o_msg_get_wait(dev->iop, &msg, I2O_TIMEOUT_MESSAGE_GET);
221         if (m == I2O_QUEUE_EMPTY)
222                 return -ETIMEDOUT;
223
224         writel(FIVE_WORD_MSG_SIZE | SGL_OFFSET_0, &msg->u.head[0]);
225         writel(I2O_CMD_BLOCK_MUNLOCK << 24 | HOST_TID << 12 | dev->lct_data.tid,
226                &msg->u.head[1]);
227         writel(media_id, &msg->body[0]);
228         osm_debug("Unlocking...\n");
229
230         return i2o_msg_post_wait(dev->iop, m, 2);
231 };
232
233 /**
234  *      i2o_block_device_power - Power management for device dev
235  *      @dev: I2O device which should receive the power management request
236  *      @operation: Operation which should be send
237  *
238  *      Send a power management request to the device dev.
239  *
240  *      Returns 0 on success or negative error code on failure.
241  */
242 static int i2o_block_device_power(struct i2o_block_device *dev, u8 op)
243 {
244         struct i2o_device *i2o_dev = dev->i2o_dev;
245         struct i2o_controller *c = i2o_dev->iop;
246         struct i2o_message __iomem *msg;
247         u32 m;
248         int rc;
249
250         m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
251         if (m == I2O_QUEUE_EMPTY)
252                 return -ETIMEDOUT;
253
254         writel(FOUR_WORD_MSG_SIZE | SGL_OFFSET_0, &msg->u.head[0]);
255         writel(I2O_CMD_BLOCK_POWER << 24 | HOST_TID << 12 | i2o_dev->lct_data.
256                tid, &msg->u.head[1]);
257         writel(op << 24, &msg->body[0]);
258         osm_debug("Power...\n");
259
260         rc = i2o_msg_post_wait(c, m, 60);
261         if (!rc)
262                 dev->power = op;
263
264         return rc;
265 };
266
267 /**
268  *      i2o_block_request_alloc - Allocate an I2O block request struct
269  *
270  *      Allocates an I2O block request struct and initialize the list.
271  *
272  *      Returns a i2o_block_request pointer on success or negative error code
273  *      on failure.
274  */
275 static inline struct i2o_block_request *i2o_block_request_alloc(void)
276 {
277         struct i2o_block_request *ireq;
278
279         ireq = mempool_alloc(i2o_blk_req_pool.pool, GFP_ATOMIC);
280         if (!ireq)
281                 return ERR_PTR(-ENOMEM);
282
283         INIT_LIST_HEAD(&ireq->queue);
284
285         return ireq;
286 };
287
288 /**
289  *      i2o_block_request_free - Frees a I2O block request
290  *      @ireq: I2O block request which should be freed
291  *
292  *      Fres the allocated memory (give it back to the request mempool).
293  */
294 static inline void i2o_block_request_free(struct i2o_block_request *ireq)
295 {
296         mempool_free(ireq, i2o_blk_req_pool.pool);
297 };
298
299 /**
300  *      i2o_block_sglist_alloc - Allocate the SG list and map it
301  *      @ireq: I2O block request
302  *
303  *      Builds the SG list and map it into to be accessable by the controller.
304  *
305  *      Returns the number of elements in the SG list or 0 on failure.
306  */
307 static inline int i2o_block_sglist_alloc(struct i2o_block_request *ireq)
308 {
309         struct device *dev = &ireq->i2o_blk_dev->i2o_dev->iop->pdev->dev;
310         int nents;
311
312         nents = blk_rq_map_sg(ireq->req->q, ireq->req, ireq->sg_table);
313
314         if (rq_data_dir(ireq->req) == READ)
315                 ireq->sg_dma_direction = PCI_DMA_FROMDEVICE;
316         else
317                 ireq->sg_dma_direction = PCI_DMA_TODEVICE;
318
319         ireq->sg_nents = dma_map_sg(dev, ireq->sg_table, nents,
320                                     ireq->sg_dma_direction);
321
322         return ireq->sg_nents;
323 };
324
325 /**
326  *      i2o_block_sglist_free - Frees the SG list
327  *      @ireq: I2O block request from which the SG should be freed
328  *
329  *      Frees the SG list from the I2O block request.
330  */
331 static inline void i2o_block_sglist_free(struct i2o_block_request *ireq)
332 {
333         struct device *dev = &ireq->i2o_blk_dev->i2o_dev->iop->pdev->dev;
334
335         dma_unmap_sg(dev, ireq->sg_table, ireq->sg_nents,
336                      ireq->sg_dma_direction);
337 };
338
339 /**
340  *      i2o_block_prep_req_fn - Allocates I2O block device specific struct
341  *      @q: request queue for the request
342  *      @req: the request to prepare
343  *
344  *      Allocate the necessary i2o_block_request struct and connect it to
345  *      the request. This is needed that we not loose the SG list later on.
346  *
347  *      Returns BLKPREP_OK on success or BLKPREP_DEFER on failure.
348  */
349 static int i2o_block_prep_req_fn(struct request_queue *q, struct request *req)
350 {
351         struct i2o_block_device *i2o_blk_dev = q->queuedata;
352         struct i2o_block_request *ireq;
353
354         /* request is already processed by us, so return */
355         if (req->flags & REQ_SPECIAL) {
356                 osm_debug("REQ_SPECIAL already set!\n");
357                 req->flags |= REQ_DONTPREP;
358                 return BLKPREP_OK;
359         }
360
361         /* connect the i2o_block_request to the request */
362         if (!req->special) {
363                 ireq = i2o_block_request_alloc();
364                 if (unlikely(IS_ERR(ireq))) {
365                         osm_debug("unable to allocate i2o_block_request!\n");
366                         return BLKPREP_DEFER;
367                 }
368
369                 ireq->i2o_blk_dev = i2o_blk_dev;
370                 req->special = ireq;
371                 ireq->req = req;
372         } else
373                 ireq = req->special;
374
375         /* do not come back here */
376         req->flags |= REQ_DONTPREP | REQ_SPECIAL;
377
378         return BLKPREP_OK;
379 };
380
381 /**
382  *      i2o_block_delayed_request_fn - delayed request queue function
383  *      delayed_request: the delayed request with the queue to start
384  *
385  *      If the request queue is stopped for a disk, and there is no open
386  *      request, a new event is created, which calls this function to start
387  *      the queue after I2O_BLOCK_REQUEST_TIME. Otherwise the queue will never
388  *      be started again.
389  */
390 static void i2o_block_delayed_request_fn(void *delayed_request)
391 {
392         struct i2o_block_delayed_request *dreq = delayed_request;
393         struct request_queue *q = dreq->queue;
394         unsigned long flags;
395
396         spin_lock_irqsave(q->queue_lock, flags);
397         blk_start_queue(q);
398         spin_unlock_irqrestore(q->queue_lock, flags);
399         kfree(dreq);
400 };
401
402 /**
403  *      i2o_block_reply - Block OSM reply handler.
404  *      @c: I2O controller from which the message arrives
405  *      @m: message id of reply
406  *      qmsg: the actuall I2O message reply
407  *
408  *      This function gets all the message replies.
409  *
410  */
411 static int i2o_block_reply(struct i2o_controller *c, u32 m,
412                            struct i2o_message *msg)
413 {
414         struct i2o_block_request *ireq;
415         struct request *req;
416         struct i2o_block_device *dev;
417         struct request_queue *q;
418         u8 st;
419         unsigned long flags;
420
421         /* FAILed message */
422         if (unlikely(le32_to_cpu(msg->u.head[0]) & (1 << 13))) {
423                 struct i2o_message *pmsg;
424                 u32 pm;
425
426                 /*
427                  * FAILed message from controller
428                  * We increment the error count and abort it
429                  *
430                  * In theory this will never happen.  The I2O block class
431                  * specification states that block devices never return
432                  * FAILs but instead use the REQ status field...but
433                  * better be on the safe side since no one really follows
434                  * the spec to the book :)
435                  */
436                 pm = le32_to_cpu(msg->body[3]);
437                 pmsg = i2o_msg_in_to_virt(c, pm);
438
439                 req = i2o_cntxt_list_get(c, le32_to_cpu(pmsg->u.s.tcntxt));
440                 if (unlikely(!req)) {
441                         osm_err("NULL reply received!\n");
442                         return -1;
443                 }
444
445                 ireq = req->special;
446                 dev = ireq->i2o_blk_dev;
447                 q = dev->gd->queue;
448
449                 req->errors++;
450
451                 spin_lock_irqsave(q->queue_lock, flags);
452
453                 while (end_that_request_chunk(req, !req->errors,
454                                               le32_to_cpu(pmsg->body[1]))) ;
455                 end_that_request_last(req);
456
457                 dev->open_queue_depth--;
458                 list_del(&ireq->queue);
459                 blk_start_queue(q);
460
461                 spin_unlock_irqrestore(q->queue_lock, flags);
462
463                 /* Now flush the message by making it a NOP */
464                 i2o_msg_nop(c, pm);
465
466                 return -1;
467         }
468
469         req = i2o_cntxt_list_get(c, le32_to_cpu(msg->u.s.tcntxt));
470         if (unlikely(!req)) {
471                 osm_err("NULL reply received!\n");
472                 return -1;
473         }
474
475         ireq = req->special;
476         dev = ireq->i2o_blk_dev;
477         q = dev->gd->queue;
478
479         if (unlikely(!dev->i2o_dev)) {
480                 /*
481                  * This is HACK, but Intel Integrated RAID allows user
482                  * to delete a volume that is claimed, locked, and in use
483                  * by the OS. We have to check for a reply from a
484                  * non-existent device and flag it as an error or the system
485                  * goes kaput...
486                  */
487                 req->errors++;
488                 osm_warn("Data transfer to deleted device!\n");
489                 spin_lock_irqsave(q->queue_lock, flags);
490                 while (end_that_request_chunk
491                        (req, !req->errors, le32_to_cpu(msg->body[1]))) ;
492                 end_that_request_last(req);
493
494                 dev->open_queue_depth--;
495                 list_del(&ireq->queue);
496                 blk_start_queue(q);
497
498                 spin_unlock_irqrestore(q->queue_lock, flags);
499                 return -1;
500         }
501
502         /*
503          *      Lets see what is cooking. We stuffed the
504          *      request in the context.
505          */
506
507         st = le32_to_cpu(msg->body[0]) >> 24;
508
509         if (st != 0) {
510                 int err;
511                 char *bsa_errors[] = {
512                         "Success",
513                         "Media Error",
514                         "Failure communicating to device",
515                         "Device Failure",
516                         "Device is not ready",
517                         "Media not present",
518                         "Media is locked by another user",
519                         "Media has failed",
520                         "Failure communicating to device",
521                         "Device bus failure",
522                         "Device is locked by another user",
523                         "Device is write protected",
524                         "Device has reset",
525                         "Volume has changed, waiting for acknowledgement"
526                 };
527
528                 err = le32_to_cpu(msg->body[0]) & 0xffff;
529
530                 /*
531                  *      Device not ready means two things. One is that the
532                  *      the thing went offline (but not a removal media)
533                  *
534                  *      The second is that you have a SuperTrak 100 and the
535                  *      firmware got constipated. Unlike standard i2o card
536                  *      setups the supertrak returns an error rather than
537                  *      blocking for the timeout in these cases.
538                  *
539                  *      Don't stick a supertrak100 into cache aggressive modes
540                  */
541
542                 osm_err("block-osm: /dev/%s error: %s", dev->gd->disk_name,
543                         bsa_errors[le32_to_cpu(msg->body[0]) & 0xffff]);
544                 if (le32_to_cpu(msg->body[0]) & 0x00ff0000)
545                         printk(KERN_ERR " - DDM attempted %d retries",
546                                (le32_to_cpu(msg->body[0]) >> 16) & 0x00ff);
547                 printk(KERN_ERR ".\n");
548                 req->errors++;
549         } else
550                 req->errors = 0;
551
552         if (!end_that_request_chunk
553             (req, !req->errors, le32_to_cpu(msg->body[1]))) {
554                 add_disk_randomness(req->rq_disk);
555                 spin_lock_irqsave(q->queue_lock, flags);
556
557                 end_that_request_last(req);
558
559                 dev->open_queue_depth--;
560                 list_del(&ireq->queue);
561                 blk_start_queue(q);
562
563                 spin_unlock_irqrestore(q->queue_lock, flags);
564
565                 i2o_block_sglist_free(ireq);
566                 i2o_block_request_free(ireq);
567         } else
568                 osm_err("still remaining chunks\n");
569
570         return 1;
571 };
572
573 static void i2o_block_event(struct i2o_event *evt)
574 {
575         osm_info("block-osm: event received\n");
576         kfree(evt);
577 };
578
579 /*
580  *      SCSI-CAM for ioctl geometry mapping
581  *      Duplicated with SCSI - this should be moved into somewhere common
582  *      perhaps genhd ?
583  *
584  * LBA -> CHS mapping table taken from:
585  *
586  * "Incorporating the I2O Architecture into BIOS for Intel Architecture
587  *  Platforms"
588  *
589  * This is an I2O document that is only available to I2O members,
590  * not developers.
591  *
592  * From my understanding, this is how all the I2O cards do this
593  *
594  * Disk Size      | Sectors | Heads | Cylinders
595  * ---------------+---------+-------+-------------------
596  * 1 < X <= 528M  | 63      | 16    | X/(63 * 16 * 512)
597  * 528M < X <= 1G | 63      | 32    | X/(63 * 32 * 512)
598  * 1 < X <528M    | 63      | 16    | X/(63 * 16 * 512)
599  * 1 < X <528M    | 63      | 16    | X/(63 * 16 * 512)
600  *
601  */
602 #define BLOCK_SIZE_528M         1081344
603 #define BLOCK_SIZE_1G           2097152
604 #define BLOCK_SIZE_21G          4403200
605 #define BLOCK_SIZE_42G          8806400
606 #define BLOCK_SIZE_84G          17612800
607
608 static void i2o_block_biosparam(unsigned long capacity, unsigned short *cyls,
609                                 unsigned char *hds, unsigned char *secs)
610 {
611         unsigned long heads, sectors, cylinders;
612
613         sectors = 63L;          /* Maximize sectors per track */
614         if (capacity <= BLOCK_SIZE_528M)
615                 heads = 16;
616         else if (capacity <= BLOCK_SIZE_1G)
617                 heads = 32;
618         else if (capacity <= BLOCK_SIZE_21G)
619                 heads = 64;
620         else if (capacity <= BLOCK_SIZE_42G)
621                 heads = 128;
622         else
623                 heads = 255;
624
625         cylinders = (unsigned long)capacity / (heads * sectors);
626
627         *cyls = (unsigned short)cylinders;      /* Stuff return values */
628         *secs = (unsigned char)sectors;
629         *hds = (unsigned char)heads;
630 }
631
632 /**
633  *      i2o_block_open - Open the block device
634  *
635  *      Power up the device, mount and lock the media. This function is called,
636  *      if the block device is opened for access.
637  *
638  *      Returns 0 on success or negative error code on failure.
639  */
640 static int i2o_block_open(struct inode *inode, struct file *file)
641 {
642         struct i2o_block_device *dev = inode->i_bdev->bd_disk->private_data;
643
644         if (!dev->i2o_dev)
645                 return -ENODEV;
646
647         if (dev->power > 0x1f)
648                 i2o_block_device_power(dev, 0x02);
649
650         i2o_block_device_mount(dev->i2o_dev, -1);
651
652         i2o_block_device_lock(dev->i2o_dev, -1);
653
654         osm_debug("Ready.\n");
655
656         return 0;
657 };
658
659 /**
660  *      i2o_block_release - Release the I2O block device
661  *
662  *      Unlock and unmount the media, and power down the device. Gets called if
663  *      the block device is closed.
664  *
665  *      Returns 0 on success or negative error code on failure.
666  */
667 static int i2o_block_release(struct inode *inode, struct file *file)
668 {
669         struct gendisk *disk = inode->i_bdev->bd_disk;
670         struct i2o_block_device *dev = disk->private_data;
671         u8 operation;
672
673         /*
674          * This is to deail with the case of an application
675          * opening a device and then the device dissapears while
676          * it's in use, and then the application tries to release
677          * it.  ex: Unmounting a deleted RAID volume at reboot.
678          * If we send messages, it will just cause FAILs since
679          * the TID no longer exists.
680          */
681         if (!dev->i2o_dev)
682                 return 0;
683
684         i2o_block_device_flush(dev->i2o_dev);
685
686         i2o_block_device_unlock(dev->i2o_dev, -1);
687
688         if (dev->flags & (1 << 3 | 1 << 4))     /* Removable */
689                 operation = 0x21;
690         else
691                 operation = 0x24;
692
693         i2o_block_device_power(dev, operation);
694
695         return 0;
696 }
697
698 /**
699  *      i2o_block_ioctl - Issue device specific ioctl calls.
700  *      @cmd: ioctl command
701  *      @arg: arg
702  *
703  *      Handles ioctl request for the block device.
704  *
705  *      Return 0 on success or negative error on failure.
706  */
707 static int i2o_block_ioctl(struct inode *inode, struct file *file,
708                            unsigned int cmd, unsigned long arg)
709 {
710         struct gendisk *disk = inode->i_bdev->bd_disk;
711         struct i2o_block_device *dev = disk->private_data;
712         void __user *argp = (void __user *)arg;
713
714         /* Anyone capable of this syscall can do *real bad* things */
715
716         if (!capable(CAP_SYS_ADMIN))
717                 return -EPERM;
718
719         switch (cmd) {
720         case HDIO_GETGEO:
721                 {
722                         struct hd_geometry g;
723                         i2o_block_biosparam(get_capacity(disk),
724                                             &g.cylinders, &g.heads, &g.sectors);
725                         g.start = get_start_sect(inode->i_bdev);
726                         return copy_to_user(argp, &g, sizeof(g)) ? -EFAULT : 0;
727                 }
728
729         case BLKI2OGRSTRAT:
730                 return put_user(dev->rcache, (int __user *)arg);
731         case BLKI2OGWSTRAT:
732                 return put_user(dev->wcache, (int __user *)arg);
733         case BLKI2OSRSTRAT:
734                 if (arg < 0 || arg > CACHE_SMARTFETCH)
735                         return -EINVAL;
736                 dev->rcache = arg;
737                 break;
738         case BLKI2OSWSTRAT:
739                 if (arg != 0
740                     && (arg < CACHE_WRITETHROUGH || arg > CACHE_SMARTBACK))
741                         return -EINVAL;
742                 dev->wcache = arg;
743                 break;
744         }
745         return -ENOTTY;
746 };
747
748 /**
749  *      i2o_block_media_changed - Have we seen a media change?
750  *      @disk: gendisk which should be verified
751  *
752  *      Verifies if the media has changed.
753  *
754  *      Returns 1 if the media was changed or 0 otherwise.
755  */
756 static int i2o_block_media_changed(struct gendisk *disk)
757 {
758         struct i2o_block_device *p = disk->private_data;
759
760         if (p->media_change_flag) {
761                 p->media_change_flag = 0;
762                 return 1;
763         }
764         return 0;
765 }
766
767 /**
768  *      i2o_block_transfer - Transfer a request to/from the I2O controller
769  *      @req: the request which should be transfered
770  *
771  *      This function converts the request into a I2O message. The necessary
772  *      DMA buffers are allocated and after everything is setup post the message
773  *      to the I2O controller. No cleanup is done by this function. It is done
774  *      on the interrupt side when the reply arrives.
775  *
776  *      Return 0 on success or negative error code on failure.
777  */
778 static int i2o_block_transfer(struct request *req)
779 {
780         struct i2o_block_device *dev = req->rq_disk->private_data;
781         struct i2o_controller *c = dev->i2o_dev->iop;
782         int tid = dev->i2o_dev->lct_data.tid;
783         struct i2o_message __iomem *msg;
784         void __iomem *mptr;
785         struct i2o_block_request *ireq = req->special;
786         struct scatterlist *sg;
787         int sgnum;
788         int i;
789         u32 m;
790         u32 tcntxt;
791         u32 sg_flags;
792         int rc;
793
794         m = i2o_msg_get(c, &msg);
795         if (m == I2O_QUEUE_EMPTY) {
796                 rc = -EBUSY;
797                 goto exit;
798         }
799
800         tcntxt = i2o_cntxt_list_add(c, req);
801         if (!tcntxt) {
802                 rc = -ENOMEM;
803                 goto nop_msg;
804         }
805
806         if ((sgnum = i2o_block_sglist_alloc(ireq)) <= 0) {
807                 rc = -ENOMEM;
808                 goto context_remove;
809         }
810
811         /* Build the message based on the request. */
812         writel(i2o_block_driver.context, &msg->u.s.icntxt);
813         writel(tcntxt, &msg->u.s.tcntxt);
814         writel(req->nr_sectors << 9, &msg->body[1]);
815
816         writel((((u64) req->sector) << 9) & 0xffffffff, &msg->body[2]);
817         writel(req->sector >> 23, &msg->body[3]);
818
819         mptr = &msg->body[4];
820
821         sg = ireq->sg_table;
822
823         if (rq_data_dir(req) == READ) {
824                 writel(I2O_CMD_BLOCK_READ << 24 | HOST_TID << 12 | tid,
825                        &msg->u.head[1]);
826                 sg_flags = 0x10000000;
827                 switch (dev->rcache) {
828                 case CACHE_NULL:
829                         writel(0, &msg->body[0]);
830                         break;
831                 case CACHE_PREFETCH:
832                         writel(0x201F0008, &msg->body[0]);
833                         break;
834                 case CACHE_SMARTFETCH:
835                         if (req->nr_sectors > 16)
836                                 writel(0x201F0008, &msg->body[0]);
837                         else
838                                 writel(0x001F0000, &msg->body[0]);
839                         break;
840                 }
841         } else {
842                 writel(I2O_CMD_BLOCK_WRITE << 24 | HOST_TID << 12 | tid,
843                        &msg->u.head[1]);
844                 sg_flags = 0x14000000;
845                 switch (dev->wcache) {
846                 case CACHE_NULL:
847                         writel(0, &msg->body[0]);
848                         break;
849                 case CACHE_WRITETHROUGH:
850                         writel(0x001F0008, &msg->body[0]);
851                         break;
852                 case CACHE_WRITEBACK:
853                         writel(0x001F0010, &msg->body[0]);
854                         break;
855                 case CACHE_SMARTBACK:
856                         if (req->nr_sectors > 16)
857                                 writel(0x001F0004, &msg->body[0]);
858                         else
859                                 writel(0x001F0010, &msg->body[0]);
860                         break;
861                 case CACHE_SMARTTHROUGH:
862                         if (req->nr_sectors > 16)
863                                 writel(0x001F0004, &msg->body[0]);
864                         else
865                                 writel(0x001F0010, &msg->body[0]);
866                 }
867         }
868
869         for (i = sgnum; i > 0; i--) {
870                 if (i == 1)
871                         sg_flags |= 0x80000000;
872                 writel(sg_flags | sg_dma_len(sg), mptr);
873                 writel(sg_dma_address(sg), mptr + 4);
874                 mptr += 8;
875                 sg++;
876         }
877
878         writel(I2O_MESSAGE_SIZE
879                (((unsigned long)mptr -
880                  (unsigned long)&msg->u.head[0]) >> 2) | SGL_OFFSET_8,
881                &msg->u.head[0]);
882
883         list_add_tail(&ireq->queue, &dev->open_queue);
884         dev->open_queue_depth++;
885
886         i2o_msg_post(c, m);
887
888         return 0;
889
890       context_remove:
891         i2o_cntxt_list_remove(c, req);
892
893       nop_msg:
894         i2o_msg_nop(c, m);
895
896       exit:
897         return rc;
898 };
899
900 /**
901  *      i2o_block_request_fn - request queue handling function
902  *      q: request queue from which the request could be fetched
903  *
904  *      Takes the next request from the queue, transfers it and if no error
905  *      occurs dequeue it from the queue. On arrival of the reply the message
906  *      will be processed further. If an error occurs requeue the request.
907  */
908 static void i2o_block_request_fn(struct request_queue *q)
909 {
910         struct request *req;
911
912         while (!blk_queue_plugged(q)) {
913                 req = elv_next_request(q);
914                 if (!req)
915                         break;
916
917                 if (blk_fs_request(req)) {
918                         struct i2o_block_delayed_request *dreq;
919                         struct i2o_block_request *ireq = req->special;
920                         unsigned int queue_depth;
921
922                         queue_depth = ireq->i2o_blk_dev->open_queue_depth;
923
924                         if (queue_depth < I2O_BLOCK_MAX_OPEN_REQUESTS)
925                                 if (!i2o_block_transfer(req)) {
926                                         blkdev_dequeue_request(req);
927                                         continue;
928                                 }
929
930                         if (queue_depth)
931                                 break;
932
933                         /* stop the queue and retry later */
934                         dreq = kmalloc(sizeof(*dreq), GFP_ATOMIC);
935                         if (!dreq)
936                                 continue;
937
938                         dreq->queue = q;
939                         INIT_WORK(&dreq->work, i2o_block_delayed_request_fn,
940                                   dreq);
941
942                         osm_info("transfer error\n");
943                         if (!queue_delayed_work(i2o_block_driver.event_queue,
944                                                 &dreq->work,
945                                                 I2O_BLOCK_RETRY_TIME))
946                                 kfree(dreq);
947                         else {
948                                 blk_stop_queue(q);
949                                 break;
950                         }
951                 } else
952                         end_request(req, 0);
953         }
954 };
955
956 /* I2O Block device operations definition */
957 static struct block_device_operations i2o_block_fops = {
958         .owner = THIS_MODULE,
959         .open = i2o_block_open,
960         .release = i2o_block_release,
961         .ioctl = i2o_block_ioctl,
962         .media_changed = i2o_block_media_changed
963 };
964
965 /**
966  *      i2o_block_device_alloc - Allocate memory for a I2O Block device
967  *
968  *      Allocate memory for the i2o_block_device struct, gendisk and request
969  *      queue and initialize them as far as no additional information is needed.
970  *
971  *      Returns a pointer to the allocated I2O Block device on succes or a
972  *      negative error code on failure.
973  */
974 static struct i2o_block_device *i2o_block_device_alloc(void)
975 {
976         struct i2o_block_device *dev;
977         struct gendisk *gd;
978         struct request_queue *queue;
979         int rc;
980
981         dev = kmalloc(sizeof(*dev), GFP_KERNEL);
982         if (!dev) {
983                 osm_err("Insufficient memory to allocate I2O Block disk.\n");
984                 rc = -ENOMEM;
985                 goto exit;
986         }
987         memset(dev, 0, sizeof(*dev));
988
989         INIT_LIST_HEAD(&dev->open_queue);
990         spin_lock_init(&dev->lock);
991         dev->rcache = CACHE_PREFETCH;
992         dev->wcache = CACHE_WRITEBACK;
993
994         /* allocate a gendisk with 16 partitions */
995         gd = alloc_disk(16);
996         if (!gd) {
997                 osm_err("Insufficient memory to allocate gendisk.\n");
998                 rc = -ENOMEM;
999                 goto cleanup_dev;
1000         }
1001
1002         /* initialize the request queue */
1003         queue = blk_init_queue(i2o_block_request_fn, &dev->lock);
1004         if (!queue) {
1005                 osm_err("Insufficient memory to allocate request queue.\n");
1006                 rc = -ENOMEM;
1007                 goto cleanup_queue;
1008         }
1009
1010         blk_queue_prep_rq(queue, i2o_block_prep_req_fn);
1011
1012         gd->major = I2O_MAJOR;
1013         gd->queue = queue;
1014         gd->fops = &i2o_block_fops;
1015         gd->private_data = dev;
1016
1017         dev->gd = gd;
1018
1019         return dev;
1020
1021       cleanup_queue:
1022         put_disk(gd);
1023
1024       cleanup_dev:
1025         kfree(dev);
1026
1027       exit:
1028         return ERR_PTR(rc);
1029 };
1030
1031 /**
1032  *      i2o_block_probe - verify if dev is a I2O Block device and install it
1033  *      @dev: device to verify if it is a I2O Block device
1034  *
1035  *      We only verify if the user_tid of the device is 0xfff and then install
1036  *      the device. Otherwise it is used by some other device (e. g. RAID).
1037  *
1038  *      Returns 0 on success or negative error code on failure.
1039  */
1040 static int i2o_block_probe(struct device *dev)
1041 {
1042         struct i2o_device *i2o_dev = to_i2o_device(dev);
1043         struct i2o_block_device *i2o_blk_dev;
1044         struct i2o_controller *c = i2o_dev->iop;
1045         struct gendisk *gd;
1046         struct request_queue *queue;
1047         static int unit = 0;
1048         int rc;
1049         u64 size;
1050         u32 blocksize;
1051         u16 power;
1052         u32 flags, status;
1053         int segments;
1054
1055         /* skip devices which are used by IOP */
1056         if (i2o_dev->lct_data.user_tid != 0xfff) {
1057                 osm_debug("skipping used device %03x\n", i2o_dev->lct_data.tid);
1058                 return -ENODEV;
1059         }
1060
1061         osm_info("New device detected (TID: %03x)\n", i2o_dev->lct_data.tid);
1062
1063         if (i2o_device_claim(i2o_dev)) {
1064                 osm_warn("Unable to claim device. Installation aborted\n");
1065                 rc = -EFAULT;
1066                 goto exit;
1067         }
1068
1069         i2o_blk_dev = i2o_block_device_alloc();
1070         if (IS_ERR(i2o_blk_dev)) {
1071                 osm_err("could not alloc a new I2O block device");
1072                 rc = PTR_ERR(i2o_blk_dev);
1073                 goto claim_release;
1074         }
1075
1076         i2o_blk_dev->i2o_dev = i2o_dev;
1077         dev_set_drvdata(dev, i2o_blk_dev);
1078
1079         /* setup gendisk */
1080         gd = i2o_blk_dev->gd;
1081         gd->first_minor = unit << 4;
1082         sprintf(gd->disk_name, "i2o/hd%c", 'a' + unit);
1083         sprintf(gd->devfs_name, "i2o/hd%c", 'a' + unit);
1084         gd->driverfs_dev = &i2o_dev->device;
1085
1086         /* setup request queue */
1087         queue = gd->queue;
1088         queue->queuedata = i2o_blk_dev;
1089
1090         blk_queue_max_phys_segments(queue, I2O_MAX_SEGMENTS);
1091         blk_queue_max_sectors(queue, I2O_MAX_SECTORS);
1092
1093         if (c->short_req)
1094                 segments = 8;
1095         else {
1096                 i2o_status_block *sb;
1097
1098                 sb = c->status_block.virt;
1099
1100                 segments = (sb->inbound_frame_size -
1101                             sizeof(struct i2o_message) / 4 - 4) / 2;
1102         }
1103
1104         blk_queue_max_hw_segments(queue, segments);
1105
1106         osm_debug("max sectors = %d\n", I2O_MAX_SECTORS);
1107         osm_debug("phys segments = %d\n", I2O_MAX_SEGMENTS);
1108         osm_debug("hw segments = %d\n", segments);
1109
1110         /*
1111          *      Ask for the current media data. If that isn't supported
1112          *      then we ask for the device capacity data
1113          */
1114         if (i2o_parm_field_get(i2o_dev, 0x0004, 1, &blocksize, 4) != 0
1115             || i2o_parm_field_get(i2o_dev, 0x0004, 0, &size, 8) != 0) {
1116                 i2o_parm_field_get(i2o_dev, 0x0000, 3, &blocksize, 4);
1117                 i2o_parm_field_get(i2o_dev, 0x0000, 4, &size, 8);
1118         }
1119         osm_debug("blocksize = %d\n", blocksize);
1120
1121         if (i2o_parm_field_get(i2o_dev, 0x0000, 2, &power, 2))
1122                 power = 0;
1123         i2o_parm_field_get(i2o_dev, 0x0000, 5, &flags, 4);
1124         i2o_parm_field_get(i2o_dev, 0x0000, 6, &status, 4);
1125
1126         set_capacity(gd, size >> 9);
1127
1128         i2o_event_register(i2o_dev, &i2o_block_driver, 0, 0xffffffff);
1129
1130         add_disk(gd);
1131
1132         unit++;
1133
1134         return 0;
1135
1136       claim_release:
1137         i2o_device_claim_release(i2o_dev);
1138
1139       exit:
1140         return rc;
1141 };
1142
1143 /* Block OSM driver struct */
1144 static struct i2o_driver i2o_block_driver = {
1145         .name = OSM_NAME,
1146         .event = i2o_block_event,
1147         .reply = i2o_block_reply,
1148         .classes = i2o_block_class_id,
1149         .driver = {
1150                    .probe = i2o_block_probe,
1151                    .remove = i2o_block_remove,
1152                    },
1153 };
1154
1155 /**
1156  *      i2o_block_init - Block OSM initialization function
1157  *
1158  *      Allocate the slab and mempool for request structs, registers i2o_block
1159  *      block device and finally register the Block OSM in the I2O core.
1160  *
1161  *      Returns 0 on success or negative error code on failure.
1162  */
1163 static int __init i2o_block_init(void)
1164 {
1165         int rc;
1166         int size;
1167
1168         printk(KERN_INFO OSM_DESCRIPTION " v" OSM_VERSION "\n");
1169
1170         /* Allocate request mempool and slab */
1171         size = sizeof(struct i2o_block_request);
1172         i2o_blk_req_pool.slab = kmem_cache_create("i2o_block_req", size, 0,
1173                                                   SLAB_HWCACHE_ALIGN, NULL,
1174                                                   NULL);
1175         if (!i2o_blk_req_pool.slab) {
1176                 osm_err("can't init request slab\n");
1177                 rc = -ENOMEM;
1178                 goto exit;
1179         }
1180
1181         i2o_blk_req_pool.pool = mempool_create(I2O_REQ_MEMPOOL_SIZE,
1182                                                mempool_alloc_slab,
1183                                                mempool_free_slab,
1184                                                i2o_blk_req_pool.slab);
1185         if (!i2o_blk_req_pool.pool) {
1186                 osm_err("can't init request mempool\n");
1187                 rc = -ENOMEM;
1188                 goto free_slab;
1189         }
1190
1191         /* Register the block device interfaces */
1192         rc = register_blkdev(I2O_MAJOR, "i2o_block");
1193         if (rc) {
1194                 osm_err("unable to register block device\n");
1195                 goto free_mempool;
1196         }
1197 #ifdef MODULE
1198         osm_info("registered device at major %d\n", I2O_MAJOR);
1199 #endif
1200
1201         /* Register Block OSM into I2O core */
1202         rc = i2o_driver_register(&i2o_block_driver);
1203         if (rc) {
1204                 osm_err("Could not register Block driver\n");
1205                 goto unregister_blkdev;
1206         }
1207
1208         return 0;
1209
1210       unregister_blkdev:
1211         unregister_blkdev(I2O_MAJOR, "i2o_block");
1212
1213       free_mempool:
1214         mempool_destroy(i2o_blk_req_pool.pool);
1215
1216       free_slab:
1217         kmem_cache_destroy(i2o_blk_req_pool.slab);
1218
1219       exit:
1220         return rc;
1221 };
1222
1223 /**
1224  *      i2o_block_exit - Block OSM exit function
1225  *
1226  *      Unregisters Block OSM from I2O core, unregisters i2o_block block device
1227  *      and frees the mempool and slab.
1228  */
1229 static void __exit i2o_block_exit(void)
1230 {
1231         /* Unregister I2O Block OSM from I2O core */
1232         i2o_driver_unregister(&i2o_block_driver);
1233
1234         /* Unregister block device */
1235         unregister_blkdev(I2O_MAJOR, "i2o_block");
1236
1237         /* Free request mempool and slab */
1238         mempool_destroy(i2o_blk_req_pool.pool);
1239         kmem_cache_destroy(i2o_blk_req_pool.slab);
1240 };
1241
1242 MODULE_AUTHOR("Red Hat");
1243 MODULE_LICENSE("GPL");
1244 MODULE_DESCRIPTION(OSM_DESCRIPTION);
1245 MODULE_VERSION(OSM_VERSION);
1246
1247 module_init(i2o_block_init);
1248 module_exit(i2o_block_exit);