]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/staging/spectra/ffsport.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Staging: spectra: removes q->prepare_flush_fn, fix build breakage
[net-next-2.6.git] / drivers / staging / spectra / ffsport.c
CommitLineData
494a43bb
AO		 1/*
2 * NAND Flash Controller Device Driver
3 * Copyright (c) 2009, Intel Corporation and its suppliers.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
17 *
18 */
19
20#include "ffsport.h"
21#include "flash.h"
22#include <linux/interrupt.h>
23#include <linux/delay.h>
24#include <linux/blkdev.h>
25#include <linux/wait.h>
26#include <linux/mutex.h>
27#include <linux/kthread.h>
28#include <linux/log2.h>
29#include <linux/init.h>
30
31/**** Helper functions used for Div, Remainder operation on u64 ****/
32
33/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
34* Function: GLOB_Calc_Used_Bits
35* Inputs: Power of 2 number
36* Outputs: Number of Used Bits
37* 0, if the argument is 0
38* Description: Calculate the number of bits used by a given power of 2 number
39* Number can be upto 32 bit
40*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
41int GLOB_Calc_Used_Bits(u32 n)
42{
43 int tot_bits = 0;
44
45 if (n >= 1 << 16) {
46 n >>= 16;
47 tot_bits += 16;
48 }
49
50 if (n >= 1 << 8) {
51 n >>= 8;
52 tot_bits += 8;
53 }
54
55 if (n >= 1 << 4) {
56 n >>= 4;
57 tot_bits += 4;
58 }
59
60 if (n >= 1 << 2) {
61 n >>= 2;
62 tot_bits += 2;
63 }
64
65 if (n >= 1 << 1)
66 tot_bits += 1;
67
68 return ((n == 0) ? (0) : tot_bits);
69}
70
71/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
72* Function: GLOB_u64_Div
73* Inputs: Number of u64
74* A power of 2 number as Division
75* Outputs: Quotient of the Divisor operation
76* Description: It divides the address by divisor by using bit shift operation
77* (essentially without explicitely using "/").
78* Divisor is a power of 2 number and Divided is of u64
79*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
80u64 GLOB_u64_Div(u64 addr, u32 divisor)
81{
82 return (u64)(addr >> GLOB_Calc_Used_Bits(divisor));
83}
84
85/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
86* Function: GLOB_u64_Remainder
87* Inputs: Number of u64
88* Divisor Type (1 -PageAddress, 2- BlockAddress)
89* Outputs: Remainder of the Division operation
90* Description: It calculates the remainder of a number (of u64) by
91* divisor(power of 2 number ) by using bit shifting and multiply
92* operation(essentially without explicitely using "/").
93*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
94u64 GLOB_u64_Remainder(u64 addr, u32 divisor_type)
95{
96 u64 result = 0;
97
98 if (divisor_type == 1) { /* Remainder -- Page */
99 result = (addr >> DeviceInfo.nBitsInPageDataSize);
100 result = result * DeviceInfo.wPageDataSize;
101 } else if (divisor_type == 2) { /* Remainder -- Block */
102 result = (addr >> DeviceInfo.nBitsInBlockDataSize);
103 result = result * DeviceInfo.wBlockDataSize;
104 }
105
106 result = addr - result;
107
108 return result;
109}
110
111#define NUM_DEVICES 1
112#define PARTITIONS 8
113
114#define GLOB_SBD_NAME "nd"
115#define GLOB_SBD_IRQ_NUM (29)
116#define GLOB_VERSION "driver version 20091110"
117
118#define GLOB_SBD_IOCTL_GC (0x7701)
119#define GLOB_SBD_IOCTL_WL (0x7702)
120#define GLOB_SBD_IOCTL_FORMAT (0x7703)
121#define GLOB_SBD_IOCTL_ERASE_FLASH (0x7704)
122#define GLOB_SBD_IOCTL_FLUSH_CACHE (0x7705)
123#define GLOB_SBD_IOCTL_COPY_BLK_TABLE (0x7706)
124#define GLOB_SBD_IOCTL_COPY_WEAR_LEVELING_TABLE (0x7707)
125#define GLOB_SBD_IOCTL_GET_NAND_INFO (0x7708)
126#define GLOB_SBD_IOCTL_WRITE_DATA (0x7709)
127#define GLOB_SBD_IOCTL_READ_DATA (0x770A)
128
90d59828
DW		 129static int reserved_mb = 0;
130module_param(reserved_mb, int, 0);
131MODULE_PARM_DESC(reserved_mb, "Reserved space for OS image, in MiB (default 25 MiB)");
494a43bb
AO		 132
133int nand_debug_level;
134module_param(nand_debug_level, int, 0644);
135MODULE_PARM_DESC(nand_debug_level, "debug level value: 1-3");
136
137MODULE_LICENSE("GPL");
138
139struct spectra_nand_dev {
140 struct pci_dev *dev;
141 u64 size;
142 u16 users;
143 spinlock_t qlock;
144 void __iomem *ioaddr; /* Mapped address */
145 struct request_queue *queue;
146 struct task_struct *thread;
147 struct gendisk *gd;
148 u8 *tmp_buf;
149};
150
151
152static int GLOB_SBD_majornum;
153
154static char *GLOB_version = GLOB_VERSION;
155
156static struct spectra_nand_dev nand_device[NUM_DEVICES];
157
158static struct mutex spectra_lock;
159
160static int res_blks_os = 1;
161
162struct spectra_indentfy_dev_tag IdentifyDeviceData;
163
164static int force_flush_cache(void)
165{
166 nand_dbg_print(NAND_DBG_DEBUG, "%s, Line %d, Function: %s\n",
167 __FILE__, __LINE__, __func__);
168
169 if (ERR == GLOB_FTL_Flush_Cache()) {
170 printk(KERN_ERR "Fail to Flush FTL Cache!\n");
171 return -EFAULT;
172 }
173#if CMD_DMA
174 if (glob_ftl_execute_cmds())
175 return -EIO;
176 else
177 return 0;
178#endif
179 return 0;
180}
181
182struct ioctl_rw_page_info {
183 u8 *data;
184 unsigned int page;
185};
186
187static int ioctl_read_page_data(unsigned long arg)
188{
189 u8 *buf;
190 struct ioctl_rw_page_info info;
191 int result = PASS;
192
193 if (copy_from_user(&info, (void __user *)arg, sizeof(info)))
194 return -EFAULT;
195
196 buf = kmalloc(IdentifyDeviceData.PageDataSize, GFP_ATOMIC);
197 if (!buf) {
198 printk(KERN_ERR "ioctl_read_page_data: "
199 "failed to allocate memory\n");
200 return -ENOMEM;
201 }
202
203 mutex_lock(&spectra_lock);
204 result = GLOB_FTL_Page_Read(buf,
205 (u64)info.page * IdentifyDeviceData.PageDataSize);
206 mutex_unlock(&spectra_lock);
207
208 if (copy_to_user((void __user *)info.data, buf,
209 IdentifyDeviceData.PageDataSize)) {
210 printk(KERN_ERR "ioctl_read_page_data: "
211 "failed to copy user data\n");
212 kfree(buf);
213 return -EFAULT;
214 }
215
216 kfree(buf);
217 return result;
218}
219
220static int ioctl_write_page_data(unsigned long arg)
221{
222 u8 *buf;
223 struct ioctl_rw_page_info info;
224 int result = PASS;
225
226 if (copy_from_user(&info, (void __user *)arg, sizeof(info)))
227 return -EFAULT;
228
229 buf = kmalloc(IdentifyDeviceData.PageDataSize, GFP_ATOMIC);
230 if (!buf) {
231 printk(KERN_ERR "ioctl_write_page_data: "
232 "failed to allocate memory\n");
233 return -ENOMEM;
234 }
235
236 if (copy_from_user(buf, (void __user *)info.data,
237 IdentifyDeviceData.PageDataSize)) {
238 printk(KERN_ERR "ioctl_write_page_data: "
239 "failed to copy user data\n");
240 kfree(buf);
241 return -EFAULT;
242 }
243
244 mutex_lock(&spectra_lock);
245 result = GLOB_FTL_Page_Write(buf,
246 (u64)info.page * IdentifyDeviceData.PageDataSize);
247 mutex_unlock(&spectra_lock);
248
249 kfree(buf);
250 return result;
251}
252
253/* Return how many blocks should be reserved for bad block replacement */
254static int get_res_blk_num_bad_blk(void)
255{
256 return IdentifyDeviceData.wDataBlockNum / 10;
257}
258
259/* Return how many blocks should be reserved for OS image */
260static int get_res_blk_num_os(void)
261{
262 u32 res_blks, blk_size;
263
264 blk_size = IdentifyDeviceData.PageDataSize *
265 IdentifyDeviceData.PagesPerBlock;
266
90d59828 267 res_blks = (reserved_mb * 1024 * 1024) / blk_size;
494a43bb
AO		 268
269 if ((res_blks < 1) || (res_blks >= IdentifyDeviceData.wDataBlockNum))
270 res_blks = 1; /* Reserved 1 block for block table */
271
272 return res_blks;
273}
274
494a43bb
AO		 275/* Transfer a full request. */
276static int do_transfer(struct spectra_nand_dev *tr, struct request *req)
277{
278 u64 start_addr, addr;
279 u32 logical_start_sect, hd_start_sect;
280 u32 nsect, hd_sects;
281 u32 rsect, tsect = 0;
282 char *buf;
283 u32 ratio = IdentifyDeviceData.PageDataSize >> 9;
284
285 start_addr = (u64)(blk_rq_pos(req)) << 9;
286 /* Add a big enough offset to prevent the OS Image from
287 * being accessed or damaged by file system */
288 start_addr += IdentifyDeviceData.PageDataSize *
289 IdentifyDeviceData.PagesPerBlock *
290 res_blks_os;
291
292 if (req->cmd_type == REQ_TYPE_LINUX_BLOCK &&
293 req->cmd[0] == REQ_LB_OP_FLUSH) {
294 if (force_flush_cache()) /* Fail to flush cache */
295 return -EIO;
296 else
297 return 0;
298 }
299
eeba34d9 300 if (req->cmd_type != REQ_TYPE_FS)
494a43bb
AO		 301 return -EIO;
302
303 if (blk_rq_pos(req) + blk_rq_cur_sectors(req) > get_capacity(tr->gd)) {
304 printk(KERN_ERR "Spectra error: request over the NAND "
305 "capacity!sector %d, current_nr_sectors %d, "
306 "while capacity is %d\n",
307 (int)blk_rq_pos(req),
308 blk_rq_cur_sectors(req),
309 (int)get_capacity(tr->gd));
310 return -EIO;
311 }
312
313 logical_start_sect = start_addr >> 9;
314 hd_start_sect = logical_start_sect / ratio;
315 rsect = logical_start_sect - hd_start_sect * ratio;
316
317 addr = (u64)hd_start_sect * ratio * 512;
318 buf = req->buffer;
319 nsect = blk_rq_cur_sectors(req);
320
321 if (rsect)
322 tsect = (ratio - rsect) < nsect ? (ratio - rsect) : nsect;
323
324 switch (rq_data_dir(req)) {
325 case READ:
326 /* Read the first NAND page */
327 if (rsect) {
328 if (GLOB_FTL_Page_Read(tr->tmp_buf, addr)) {
329 printk(KERN_ERR "Error in %s, Line %d\n",
330 __FILE__, __LINE__);
331 return -EIO;
332 }
333 memcpy(buf, tr->tmp_buf + (rsect << 9), tsect << 9);
334 addr += IdentifyDeviceData.PageDataSize;
335 buf += tsect << 9;
336 nsect -= tsect;
337 }
338
339 /* Read the other NAND pages */
340 for (hd_sects = nsect / ratio; hd_sects > 0; hd_sects--) {
341 if (GLOB_FTL_Page_Read(buf, addr)) {
342 printk(KERN_ERR "Error in %s, Line %d\n",
343 __FILE__, __LINE__);
344 return -EIO;
345 }
346 addr += IdentifyDeviceData.PageDataSize;
347 buf += IdentifyDeviceData.PageDataSize;
348 }
349
350 /* Read the last NAND pages */
351 if (nsect % ratio) {
352 if (GLOB_FTL_Page_Read(tr->tmp_buf, addr)) {
353 printk(KERN_ERR "Error in %s, Line %d\n",
354 __FILE__, __LINE__);
355 return -EIO;
356 }
357 memcpy(buf, tr->tmp_buf, (nsect % ratio) << 9);
358 }
359#if CMD_DMA
360 if (glob_ftl_execute_cmds())
361 return -EIO;
362 else
363 return 0;
364#endif
365 return 0;
366
367 case WRITE:
368 /* Write the first NAND page */
369 if (rsect) {
370 if (GLOB_FTL_Page_Read(tr->tmp_buf, addr)) {
371 printk(KERN_ERR "Error in %s, Line %d\n",
372 __FILE__, __LINE__);
373 return -EIO;
374 }
375 memcpy(tr->tmp_buf + (rsect << 9), buf, tsect << 9);
376 if (GLOB_FTL_Page_Write(tr->tmp_buf, addr)) {
377 printk(KERN_ERR "Error in %s, Line %d\n",
378 __FILE__, __LINE__);
379 return -EIO;
380 }
381 addr += IdentifyDeviceData.PageDataSize;
382 buf += tsect << 9;
383 nsect -= tsect;
384 }
385
386 /* Write the other NAND pages */
387 for (hd_sects = nsect / ratio; hd_sects > 0; hd_sects--) {
388 if (GLOB_FTL_Page_Write(buf, addr)) {
389 printk(KERN_ERR "Error in %s, Line %d\n",
390 __FILE__, __LINE__);
391 return -EIO;
392 }
393 addr += IdentifyDeviceData.PageDataSize;
394 buf += IdentifyDeviceData.PageDataSize;
395 }
396
397 /* Write the last NAND pages */
398 if (nsect % ratio) {
399 if (GLOB_FTL_Page_Read(tr->tmp_buf, addr)) {
400 printk(KERN_ERR "Error in %s, Line %d\n",
401 __FILE__, __LINE__);
402 return -EIO;
403 }
404 memcpy(tr->tmp_buf, buf, (nsect % ratio) << 9);
405 if (GLOB_FTL_Page_Write(tr->tmp_buf, addr)) {
406 printk(KERN_ERR "Error in %s, Line %d\n",
407 __FILE__, __LINE__);
408 return -EIO;
409 }
410 }
411#if CMD_DMA
412 if (glob_ftl_execute_cmds())
413 return -EIO;
414 else
415 return 0;
416#endif
417 return 0;
418
419 default:
420 printk(KERN_NOTICE "Unknown request %u\n", rq_data_dir(req));
421 return -EIO;
422 }
423}
424
425/* This function is copied from drivers/mtd/mtd_blkdevs.c */
426static int spectra_trans_thread(void *arg)
427{
428 struct spectra_nand_dev *tr = arg;
429 struct request_queue *rq = tr->queue;
430 struct request *req = NULL;
431
432 /* we might get involved when memory gets low, so use PF_MEMALLOC */
433 current->flags |= PF_MEMALLOC;
434
435 spin_lock_irq(rq->queue_lock);
436 while (!kthread_should_stop()) {
437 int res;
438
439 if (!req) {
440 req = blk_fetch_request(rq);
441 if (!req) {
442 set_current_state(TASK_INTERRUPTIBLE);
443 spin_unlock_irq(rq->queue_lock);
444 schedule();
445 spin_lock_irq(rq->queue_lock);
446 continue;
447 }
448 }
449
450 spin_unlock_irq(rq->queue_lock);
451
452 mutex_lock(&spectra_lock);
453 res = do_transfer(tr, req);
454 mutex_unlock(&spectra_lock);
455
456 spin_lock_irq(rq->queue_lock);
457
458 if (!__blk_end_request_cur(req, res))
459 req = NULL;
460 }
461
462 if (req)
463 __blk_end_request_all(req, -EIO);
464
465 spin_unlock_irq(rq->queue_lock);
466
467 return 0;
468}
469
470
471/* Request function that "handles clustering". */
472static void GLOB_SBD_request(struct request_queue *rq)
473{
474 struct spectra_nand_dev *pdev = rq->queuedata;
475 wake_up_process(pdev->thread);
476}
477
478static int GLOB_SBD_open(struct block_device *bdev, fmode_t mode)
479
480{
481 nand_dbg_print(NAND_DBG_WARN, "%s, Line %d, Function: %s\n",
482 __FILE__, __LINE__, __func__);
483 return 0;
484}
485
486static int GLOB_SBD_release(struct gendisk *disk, fmode_t mode)
487{
488 int ret;
489
490 nand_dbg_print(NAND_DBG_WARN, "%s, Line %d, Function: %s\n",
491 __FILE__, __LINE__, __func__);
492
493 mutex_lock(&spectra_lock);
494 ret = force_flush_cache();
495 mutex_unlock(&spectra_lock);
496
497 return 0;
498}
499
500static int GLOB_SBD_getgeo(struct block_device *bdev, struct hd_geometry *geo)
501{
502 geo->heads = 4;
503 geo->sectors = 16;
504 geo->cylinders = get_capacity(bdev->bd_disk) / (4 * 16);
505
506 nand_dbg_print(NAND_DBG_DEBUG,
507 "heads: %d, sectors: %d, cylinders: %d\n",
508 geo->heads, geo->sectors, geo->cylinders);
509
510 return 0;
511}
512
513int GLOB_SBD_ioctl(struct block_device *bdev, fmode_t mode,
514 unsigned int cmd, unsigned long arg)
515{
516 int ret;
517
518 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
519 __FILE__, __LINE__, __func__);
520
521 switch (cmd) {
522 case GLOB_SBD_IOCTL_GC:
523 nand_dbg_print(NAND_DBG_DEBUG,
524 "Spectra IOCTL: Garbage Collection "
525 "being performed\n");
526 if (PASS != GLOB_FTL_Garbage_Collection())
527 return -EFAULT;
528 return 0;
529
530 case GLOB_SBD_IOCTL_WL:
531 nand_dbg_print(NAND_DBG_DEBUG,
532 "Spectra IOCTL: Static Wear Leveling "
533 "being performed\n");
534 if (PASS != GLOB_FTL_Wear_Leveling())
535 return -EFAULT;
536 return 0;
537
538 case GLOB_SBD_IOCTL_FORMAT:
539 nand_dbg_print(NAND_DBG_DEBUG, "Spectra IOCTL: Flash format "
540 "being performed\n");
541 if (PASS != GLOB_FTL_Flash_Format())
542 return -EFAULT;
543 return 0;
544
545 case GLOB_SBD_IOCTL_FLUSH_CACHE:
546 nand_dbg_print(NAND_DBG_DEBUG, "Spectra IOCTL: Cache flush "
547 "being performed\n");
548 mutex_lock(&spectra_lock);
549 ret = force_flush_cache();
550 mutex_unlock(&spectra_lock);
551 return ret;
552
553 case GLOB_SBD_IOCTL_COPY_BLK_TABLE:
554 nand_dbg_print(NAND_DBG_DEBUG, "Spectra IOCTL: "
555 "Copy block table\n");
556 if (copy_to_user((void __user *)arg,
557 get_blk_table_start_addr(),
558 get_blk_table_len()))
559 return -EFAULT;
560 return 0;
561
562 case GLOB_SBD_IOCTL_COPY_WEAR_LEVELING_TABLE:
563 nand_dbg_print(NAND_DBG_DEBUG, "Spectra IOCTL: "
564 "Copy wear leveling table\n");
565 if (copy_to_user((void __user *)arg,
566 get_wear_leveling_table_start_addr(),
567 get_wear_leveling_table_len()))
568 return -EFAULT;
569 return 0;
570
571 case GLOB_SBD_IOCTL_GET_NAND_INFO:
572 nand_dbg_print(NAND_DBG_DEBUG, "Spectra IOCTL: "
573 "Get NAND info\n");
574 if (copy_to_user((void __user *)arg, &IdentifyDeviceData,
575 sizeof(IdentifyDeviceData)))
576 return -EFAULT;
577 return 0;
578
579 case GLOB_SBD_IOCTL_WRITE_DATA:
580 nand_dbg_print(NAND_DBG_DEBUG, "Spectra IOCTL: "
581 "Write one page data\n");
582 return ioctl_write_page_data(arg);
583
584 case GLOB_SBD_IOCTL_READ_DATA:
585 nand_dbg_print(NAND_DBG_DEBUG, "Spectra IOCTL: "
586 "Read one page data\n");
587 return ioctl_read_page_data(arg);
588 }
589
590 return -ENOTTY;
591}
592
593static struct block_device_operations GLOB_SBD_ops = {
594 .owner = THIS_MODULE,
595 .open = GLOB_SBD_open,
596 .release = GLOB_SBD_release,
597 .locked_ioctl = GLOB_SBD_ioctl,
598 .getgeo = GLOB_SBD_getgeo,
599};
600
601static int SBD_setup_device(struct spectra_nand_dev *dev, int which)
602{
603 int res_blks;
604 u32 sects;
605
606 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
607 __FILE__, __LINE__, __func__);
608
609 memset(dev, 0, sizeof(struct spectra_nand_dev));
610
611 nand_dbg_print(NAND_DBG_WARN, "Reserved %d blocks "
612 "for OS image, %d blocks for bad block replacement.\n",
613 get_res_blk_num_os(),
614 get_res_blk_num_bad_blk());
615
616 res_blks = get_res_blk_num_bad_blk() + get_res_blk_num_os();
617
618 dev->size = (u64)IdentifyDeviceData.PageDataSize *
619 IdentifyDeviceData.PagesPerBlock *
620 (IdentifyDeviceData.wDataBlockNum - res_blks);
621
622 res_blks_os = get_res_blk_num_os();
623
624 spin_lock_init(&dev->qlock);
625
626 dev->tmp_buf = kmalloc(IdentifyDeviceData.PageDataSize, GFP_ATOMIC);
627 if (!dev->tmp_buf) {
628 printk(KERN_ERR "Failed to kmalloc memory in %s Line %d, exit.\n",
629 __FILE__, __LINE__);
630 goto out_vfree;
631 }
632
633 dev->queue = blk_init_queue(GLOB_SBD_request, &dev->qlock);
634 if (dev->queue == NULL) {
635 printk(KERN_ERR
636 "Spectra: Request queue could not be initialized."
637 " Aborting\n ");
638 goto out_vfree;
639 }
640 dev->queue->queuedata = dev;
641
642 /* As Linux block layer doens't support >4KB hardware sector, */
643 /* Here we force report 512 byte hardware sector size to Kernel */
644 blk_queue_logical_block_size(dev->queue, 512);
645
09e74c79 646 blk_queue_ordered(dev->queue, QUEUE_ORDERED_DRAIN_FLUSH);
494a43bb
AO		 647
648 dev->thread = kthread_run(spectra_trans_thread, dev, "nand_thd");
649 if (IS_ERR(dev->thread)) {
650 blk_cleanup_queue(dev->queue);
651 unregister_blkdev(GLOB_SBD_majornum, GLOB_SBD_NAME);
652 return PTR_ERR(dev->thread);
653 }
654
655 dev->gd = alloc_disk(PARTITIONS);
656 if (!dev->gd) {
657 printk(KERN_ERR
658 "Spectra: Could not allocate disk. Aborting \n ");
659 goto out_vfree;
660 }
661 dev->gd->major = GLOB_SBD_majornum;
662 dev->gd->first_minor = which * PARTITIONS;
663 dev->gd->fops = &GLOB_SBD_ops;
664 dev->gd->queue = dev->queue;
665 dev->gd->private_data = dev;
666 snprintf(dev->gd->disk_name, 32, "%s%c", GLOB_SBD_NAME, which + 'a');
667
668 sects = dev->size >> 9;
669 nand_dbg_print(NAND_DBG_WARN, "Capacity sects: %d\n", sects);
670 set_capacity(dev->gd, sects);
671
672 add_disk(dev->gd);
673
674 return 0;
675out_vfree:
676 return -ENOMEM;
677}
678
679/*
680static ssize_t show_nand_block_num(struct device *dev,
681 struct device_attribute *attr, char *buf)
682{
683 return snprintf(buf, PAGE_SIZE, "%d\n",
684 (int)IdentifyDeviceData.wDataBlockNum);
685}
686
687static ssize_t show_nand_pages_per_block(struct device *dev,
688 struct device_attribute *attr, char *buf)
689{
690 return snprintf(buf, PAGE_SIZE, "%d\n",
691 (int)IdentifyDeviceData.PagesPerBlock);
692}
693
694static ssize_t show_nand_page_size(struct device *dev,
695 struct device_attribute *attr, char *buf)
696{
697 return snprintf(buf, PAGE_SIZE, "%d\n",
698 (int)IdentifyDeviceData.PageDataSize);
699}
700
701static DEVICE_ATTR(nand_block_num, 0444, show_nand_block_num, NULL);
702static DEVICE_ATTR(nand_pages_per_block, 0444, show_nand_pages_per_block, NULL);
703static DEVICE_ATTR(nand_page_size, 0444, show_nand_page_size, NULL);
704
705static void create_sysfs_entry(struct device *dev)
706{
707 if (device_create_file(dev, &dev_attr_nand_block_num))
708 printk(KERN_ERR "Spectra: "
709 "failed to create sysfs entry nand_block_num.\n");
710 if (device_create_file(dev, &dev_attr_nand_pages_per_block))
711 printk(KERN_ERR "Spectra: "
712 "failed to create sysfs entry nand_pages_per_block.\n");
713 if (device_create_file(dev, &dev_attr_nand_page_size))
714 printk(KERN_ERR "Spectra: "
715 "failed to create sysfs entry nand_page_size.\n");
716}
717*/
718
719static int GLOB_SBD_init(void)
720{
721 int i;
722
723 /* Set debug output level (0~3) here. 3 is most verbose */
494a43bb
AO		 724 printk(KERN_ALERT "Spectra: %s\n", GLOB_version);
725
726 mutex_init(&spectra_lock);
727
728 GLOB_SBD_majornum = register_blkdev(0, GLOB_SBD_NAME);
729 if (GLOB_SBD_majornum <= 0) {
730 printk(KERN_ERR "Unable to get the major %d for Spectra",
731 GLOB_SBD_majornum);
732 return -EBUSY;
733 }
734
735 if (PASS != GLOB_FTL_Flash_Init()) {
736 printk(KERN_ERR "Spectra: Unable to Initialize Flash Device. "
737 "Aborting\n");
738 goto out_flash_register;
739 }
740
741 /* create_sysfs_entry(&dev->dev); */
742
743 if (PASS != GLOB_FTL_IdentifyDevice(&IdentifyDeviceData)) {
744 printk(KERN_ERR "Spectra: Unable to Read Flash Device. "
745 "Aborting\n");
746 goto out_flash_register;
747 } else {
748 nand_dbg_print(NAND_DBG_WARN, "In GLOB_SBD_init: "
749 "Num blocks=%d, pagesperblock=%d, "
750 "pagedatasize=%d, ECCBytesPerSector=%d\n",
751 (int)IdentifyDeviceData.NumBlocks,
752 (int)IdentifyDeviceData.PagesPerBlock,
753 (int)IdentifyDeviceData.PageDataSize,
754 (int)IdentifyDeviceData.wECCBytesPerSector);
755 }
756
757 printk(KERN_ALERT "Spectra: searching block table, please wait ...\n");
758 if (GLOB_FTL_Init() != PASS) {
759 printk(KERN_ERR "Spectra: Unable to Initialize FTL Layer. "
760 "Aborting\n");
761 goto out_ftl_flash_register;
762 }
763 printk(KERN_ALERT "Spectra: block table has been found.\n");
764
765 for (i = 0; i < NUM_DEVICES; i++)
766 if (SBD_setup_device(&nand_device[i], i) == -ENOMEM)
767 goto out_ftl_flash_register;
768
769 nand_dbg_print(NAND_DBG_DEBUG,
770 "Spectra: module loaded with major number %d\n",
771 GLOB_SBD_majornum);
772
773 return 0;
774
775out_ftl_flash_register:
776 GLOB_FTL_Cache_Release();
777out_flash_register:
778 GLOB_FTL_Flash_Release();
779 unregister_blkdev(GLOB_SBD_majornum, GLOB_SBD_NAME);
780 printk(KERN_ERR "Spectra: Module load failed.\n");
781
782 return -ENOMEM;
783}
784
785static void __exit GLOB_SBD_exit(void)
786{
787 int i;
788
789 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
790 __FILE__, __LINE__, __func__);
791
792 for (i = 0; i < NUM_DEVICES; i++) {
793 struct spectra_nand_dev *dev = &nand_device[i];
794 if (dev->gd) {
795 del_gendisk(dev->gd);
796 put_disk(dev->gd);
797 }
798 if (dev->queue)
799 blk_cleanup_queue(dev->queue);
800 kfree(dev->tmp_buf);
801 }
802
803 unregister_blkdev(GLOB_SBD_majornum, GLOB_SBD_NAME);
804
805 mutex_lock(&spectra_lock);
806 force_flush_cache();
807 mutex_unlock(&spectra_lock);
808
809 GLOB_FTL_Cache_Release();
810
811 GLOB_FTL_Flash_Release();
812
813 nand_dbg_print(NAND_DBG_DEBUG,
814 "Spectra FTL module (major number %d) unloaded.\n",
815 GLOB_SBD_majornum);
816}
817
494a43bb
AO		 818module_init(GLOB_SBD_init);
819module_exit(GLOB_SBD_exit);
Clone of davem's net-next-2.6 tree