1/*
2* Filename: dev.c
3*
4*
5* Authors: Joshua Morris <josh.h.morris@us.ibm.com>
6*	Philip Kelleher <pjk1939@linux.vnet.ibm.com>
7*
8* (C) Copyright 2013 IBM Corporation
9*
10* This program is free software; you can redistribute it and/or
11* modify it under the terms of the GNU General Public License as
12* published by the Free Software Foundation; either version 2 of the
13* License, or (at your option) any later version.
14*
15* This program is distributed in the hope that it will be useful, but
16* WITHOUT ANY WARRANTY; without even the implied warranty of
17* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18* General Public License for more details.
19*
20* You should have received a copy of the GNU General Public License
21* along with this program; if not, write to the Free Software Foundation,
22* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23*/
24
25#include <linux/kernel.h>
26#include <linux/interrupt.h>
27#include <linux/module.h>
28#include <linux/pci.h>
29#include <linux/slab.h>
30
31#include <linux/hdreg.h>
32#include <linux/genhd.h>
33#include <linux/blkdev.h>
34#include <linux/bio.h>
35
36#include <linux/fs.h>
37
38#include "rsxx_priv.h"
39
40static unsigned int blkdev_minors = 64;
41module_param(blkdev_minors, uint, 0444);
42MODULE_PARM_DESC(blkdev_minors, "Number of minors(partitions)");
43
44/*
45 * For now I'm making this tweakable in case any applications hit this limit.
46 * If you see a "bio too big" error in the log you will need to raise this
47 * value.
48 */
49static unsigned int blkdev_max_hw_sectors = 1024;
50module_param(blkdev_max_hw_sectors, uint, 0444);
51MODULE_PARM_DESC(blkdev_max_hw_sectors, "Max hw sectors for a single BIO");
52
53static unsigned int enable_blkdev = 1;
54module_param(enable_blkdev , uint, 0444);
55MODULE_PARM_DESC(enable_blkdev, "Enable block device interfaces");
56
57
58struct rsxx_bio_meta {
59	struct bio	*bio;
60	atomic_t	pending_dmas;
61	atomic_t	error;
62	unsigned long	start_time;
63};
64
65static struct kmem_cache *bio_meta_pool;
66
67/*----------------- Block Device Operations -----------------*/
68static int rsxx_blkdev_ioctl(struct block_device *bdev,
69				 fmode_t mode,
70				 unsigned int cmd,
71				 unsigned long arg)
72{
73	struct rsxx_cardinfo *card = bdev->bd_disk->private_data;
74
75	switch (cmd) {
76	case RSXX_GETREG:
77		return rsxx_reg_access(card, (void __user *)arg, 1);
78	case RSXX_SETREG:
79		return rsxx_reg_access(card, (void __user *)arg, 0);
80	}
81
82	return -ENOTTY;
83}
84
85static int rsxx_getgeo(struct block_device *bdev, struct hd_geometry *geo)
86{
87	struct rsxx_cardinfo *card = bdev->bd_disk->private_data;
88	u64 blocks = card->size8 >> 9;
89
90	/*
91	 * get geometry: Fake it. I haven't found any drivers that set
92	 * geo->start, so we won't either.
93	 */
94	if (card->size8) {
95		geo->heads = 64;
96		geo->sectors = 16;
97		do_div(blocks, (geo->heads * geo->sectors));
98		geo->cylinders = blocks;
99	} else {
100		geo->heads = 0;
101		geo->sectors = 0;
102		geo->cylinders = 0;
103	}
104	return 0;
105}
106
107static const struct block_device_operations rsxx_fops = {
108	.owner		= THIS_MODULE,
109	.getgeo		= rsxx_getgeo,
110	.ioctl		= rsxx_blkdev_ioctl,
111};
112
113static void disk_stats_start(struct rsxx_cardinfo *card, struct bio *bio)
114{
115	generic_start_io_acct(bio_data_dir(bio), bio_sectors(bio),
116			     &card->gendisk->part0);
117}
118
119static void disk_stats_complete(struct rsxx_cardinfo *card,
120				struct bio *bio,
121				unsigned long start_time)
122{
123	generic_end_io_acct(bio_data_dir(bio), &card->gendisk->part0,
124			   start_time);
125}
126
127static void bio_dma_done_cb(struct rsxx_cardinfo *card,
128			    void *cb_data,
129			    unsigned int error)
130{
131	struct rsxx_bio_meta *meta = cb_data;
132
133	if (error)
134		atomic_set(&meta->error, 1);
135
136	if (atomic_dec_and_test(&meta->pending_dmas)) {
137		if (!card->eeh_state && card->gendisk)
138			disk_stats_complete(card, meta->bio, meta->start_time);
139
140		bio_endio(meta->bio, atomic_read(&meta->error) ? -EIO : 0);
141		kmem_cache_free(bio_meta_pool, meta);
142	}
143}
144
145static void rsxx_make_request(struct request_queue *q, struct bio *bio)
146{
147	struct rsxx_cardinfo *card = q->queuedata;
148	struct rsxx_bio_meta *bio_meta;
149	int st = -EINVAL;
150
151	might_sleep();
152
153	if (!card)
154		goto req_err;
155
156	if (bio_end_sector(bio) > get_capacity(card->gendisk))
157		goto req_err;
158
159	if (unlikely(card->halt)) {
160		st = -EFAULT;
161		goto req_err;
162	}
163
164	if (unlikely(card->dma_fault)) {
165		st = (-EFAULT);
166		goto req_err;
167	}
168
169	if (bio->bi_iter.bi_size == 0) {
170		dev_err(CARD_TO_DEV(card), "size zero BIO!\n");
171		goto req_err;
172	}
173
174	bio_meta = kmem_cache_alloc(bio_meta_pool, GFP_KERNEL);
175	if (!bio_meta) {
176		st = -ENOMEM;
177		goto req_err;
178	}
179
180	bio_meta->bio = bio;
181	atomic_set(&bio_meta->error, 0);
182	atomic_set(&bio_meta->pending_dmas, 0);
183	bio_meta->start_time = jiffies;
184
185	if (!unlikely(card->halt))
186		disk_stats_start(card, bio);
187
188	dev_dbg(CARD_TO_DEV(card), "BIO[%c]: meta: %p addr8: x%llx size: %d\n",
189		 bio_data_dir(bio) ? 'W' : 'R', bio_meta,
190		 (u64)bio->bi_iter.bi_sector << 9, bio->bi_iter.bi_size);
191
192	st = rsxx_dma_queue_bio(card, bio, &bio_meta->pending_dmas,
193				    bio_dma_done_cb, bio_meta);
194	if (st)
195		goto queue_err;
196
197	return;
198
199queue_err:
200	kmem_cache_free(bio_meta_pool, bio_meta);
201req_err:
202	bio_endio(bio, st);
203}
204
205/*----------------- Device Setup -------------------*/
206static bool rsxx_discard_supported(struct rsxx_cardinfo *card)
207{
208	unsigned char pci_rev;
209
210	pci_read_config_byte(card->dev, PCI_REVISION_ID, &pci_rev);
211
212	return (pci_rev >= RSXX_DISCARD_SUPPORT);
213}
214
215int rsxx_attach_dev(struct rsxx_cardinfo *card)
216{
217	mutex_lock(&card->dev_lock);
218
219	/* The block device requires the stripe size from the config. */
220	if (enable_blkdev) {
221		if (card->config_valid)
222			set_capacity(card->gendisk, card->size8 >> 9);
223		else
224			set_capacity(card->gendisk, 0);
225		add_disk(card->gendisk);
226
227		card->bdev_attached = 1;
228	}
229
230	mutex_unlock(&card->dev_lock);
231
232	return 0;
233}
234
235void rsxx_detach_dev(struct rsxx_cardinfo *card)
236{
237	mutex_lock(&card->dev_lock);
238
239	if (card->bdev_attached) {
240		del_gendisk(card->gendisk);
241		card->bdev_attached = 0;
242	}
243
244	mutex_unlock(&card->dev_lock);
245}
246
247int rsxx_setup_dev(struct rsxx_cardinfo *card)
248{
249	unsigned short blk_size;
250
251	mutex_init(&card->dev_lock);
252
253	if (!enable_blkdev)
254		return 0;
255
256	card->major = register_blkdev(0, DRIVER_NAME);
257	if (card->major < 0) {
258		dev_err(CARD_TO_DEV(card), "Failed to get major number\n");
259		return -ENOMEM;
260	}
261
262	card->queue = blk_alloc_queue(GFP_KERNEL);
263	if (!card->queue) {
264		dev_err(CARD_TO_DEV(card), "Failed queue alloc\n");
265		unregister_blkdev(card->major, DRIVER_NAME);
266		return -ENOMEM;
267	}
268
269	card->gendisk = alloc_disk(blkdev_minors);
270	if (!card->gendisk) {
271		dev_err(CARD_TO_DEV(card), "Failed disk alloc\n");
272		blk_cleanup_queue(card->queue);
273		unregister_blkdev(card->major, DRIVER_NAME);
274		return -ENOMEM;
275	}
276
277	if (card->config_valid) {
278		blk_size = card->config.data.block_size;
279		blk_queue_dma_alignment(card->queue, blk_size - 1);
280		blk_queue_logical_block_size(card->queue, blk_size);
281	}
282
283	blk_queue_make_request(card->queue, rsxx_make_request);
284	blk_queue_bounce_limit(card->queue, BLK_BOUNCE_ANY);
285	blk_queue_max_hw_sectors(card->queue, blkdev_max_hw_sectors);
286	blk_queue_physical_block_size(card->queue, RSXX_HW_BLK_SIZE);
287
288	queue_flag_set_unlocked(QUEUE_FLAG_NONROT, card->queue);
289	queue_flag_clear_unlocked(QUEUE_FLAG_ADD_RANDOM, card->queue);
290	if (rsxx_discard_supported(card)) {
291		queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, card->queue);
292		blk_queue_max_discard_sectors(card->queue,
293						RSXX_HW_BLK_SIZE >> 9);
294		card->queue->limits.discard_granularity = RSXX_HW_BLK_SIZE;
295		card->queue->limits.discard_alignment   = RSXX_HW_BLK_SIZE;
296		card->queue->limits.discard_zeroes_data = 1;
297	}
298
299	card->queue->queuedata = card;
300
301	snprintf(card->gendisk->disk_name, sizeof(card->gendisk->disk_name),
302		 "rsxx%d", card->disk_id);
303	card->gendisk->driverfs_dev = &card->dev->dev;
304	card->gendisk->major = card->major;
305	card->gendisk->first_minor = 0;
306	card->gendisk->fops = &rsxx_fops;
307	card->gendisk->private_data = card;
308	card->gendisk->queue = card->queue;
309
310	return 0;
311}
312
313void rsxx_destroy_dev(struct rsxx_cardinfo *card)
314{
315	if (!enable_blkdev)
316		return;
317
318	put_disk(card->gendisk);
319	card->gendisk = NULL;
320
321	blk_cleanup_queue(card->queue);
322	card->queue->queuedata = NULL;
323	unregister_blkdev(card->major, DRIVER_NAME);
324}
325
326int rsxx_dev_init(void)
327{
328	bio_meta_pool = KMEM_CACHE(rsxx_bio_meta, SLAB_HWCACHE_ALIGN);
329	if (!bio_meta_pool)
330		return -ENOMEM;
331
332	return 0;
333}
334
335void rsxx_dev_cleanup(void)
336{
337	kmem_cache_destroy(bio_meta_pool);
338}
339
340
341