asgardius/android_kernel_motorola_sm6225
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'for-linus' of git://git.kernel.dk/linux-2.6-block

Browse source 
* 'for-linus' of git://git.kernel.dk/linux-2.6-block:
  Cleanup umem driver: fix most checkpatch warnings, conform to kernel
  block: let elv_register() return void
  as-iosched: fix write batch start point
  as-iosched: fix incorrect comments
  block: use jiffies conversion functions in scsi_ioctl.c
This commit is contained in:
Linus Torvalds 2007-12-18 08:04:24 -08:00
commit 3c615e19a4
8 changed files with 100 additions and 173 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
block/as-iosched.c
View file

@ -880,7 +880,7 @@ static void as_remove_queued_request(struct request_queue *q,
}
/*
* as_fifo_expired returns 0 if there are no expired reads on the fifo,
* as_fifo_expired returns 0 if there are no expired requests on the fifo,
* 1 otherwise. It is ratelimited so that we only perform the check once per
* `fifo_expire' interval. Otherwise a large number of expired requests
* would create a hopeless seekstorm.
@ -1097,7 +1097,8 @@ dispatch_writes:
ad->batch_data_dir = REQ_ASYNC;
ad->current_write_count = ad->write_batch_count;
ad->write_batch_idled = 0;
rq = ad->next_rq[ad->batch_data_dir];
rq = rq_entry_fifo(ad->fifo_list[REQ_ASYNC].next);
ad->last_check_fifo[REQ_ASYNC] = jiffies;
goto dispatch_request;
}
@ -1159,7 +1160,7 @@ static void as_add_request(struct request_queue *q, struct request *rq)
as_add_rq_rb(ad, rq);
/*
* set expire time (only used for reads) and add to fifo list
* set expire time and add to fifo list
*/
rq_set_fifo_time(rq, jiffies + ad->fifo_expire[data_dir]);
list_add_tail(&rq->queuelist, &ad->fifo_list[data_dir]);
@ -1463,7 +1464,9 @@ static struct elevator_type iosched_as = {
static int __init as_init(void)
{
return elv_register(&iosched_as);
elv_register(&iosched_as);
return 0;
}
static void __exit as_exit(void)

8
block/cfq-iosched.c
View file

@ -2279,8 +2279,6 @@ static struct elevator_type iosched_cfq = {
static int __init cfq_init(void)
{
int ret;
/*
* could be 0 on HZ < 1000 setups
*/
@ -2292,11 +2290,9 @@ static int __init cfq_init(void)
if (cfq_slab_setup())
return -ENOMEM;
ret = elv_register(&iosched_cfq);
if (ret)
cfq_slab_kill();
elv_register(&iosched_cfq);
return ret;
return 0;
}
static void __exit cfq_exit(void)

4
block/deadline-iosched.c
View file

@ -467,7 +467,9 @@ static struct elevator_type iosched_deadline = {
static int __init deadline_init(void)
{
return elv_register(&iosched_deadline);
elv_register(&iosched_deadline);
return 0;
}
static void __exit deadline_exit(void)

3
block/elevator.c
View file

@ -960,7 +960,7 @@ void elv_unregister_queue(struct request_queue *q)
__elv_unregister_queue(q->elevator);
}
int elv_register(struct elevator_type *e)
void elv_register(struct elevator_type *e)
{
char *def = "";
@ -975,7 +975,6 @@ int elv_register(struct elevator_type *e)
def = " (default)";
printk(KERN_INFO "io scheduler %s registered%s\n", e->elevator_name, def);
return 0;
}
EXPORT_SYMBOL_GPL(elv_register);

4
block/noop-iosched.c
View file

@ -101,7 +101,9 @@ static struct elevator_type elevator_noop = {
static int __init noop_init(void)
{
return elv_register(&elevator_noop);
elv_register(&elevator_noop);
return 0;
}
static void __exit noop_exit(void)

4
block/scsi_ioctl.c
View file

@ -230,7 +230,7 @@ static int blk_fill_sghdr_rq(struct request_queue *q, struct request *rq,
rq->cmd_len = hdr->cmd_len;
rq->cmd_type = REQ_TYPE_BLOCK_PC;
rq->timeout = (hdr->timeout * HZ) / 1000;
rq->timeout = msecs_to_jiffies(hdr->timeout);
if (!rq->timeout)
rq->timeout = q->sg_timeout;
if (!rq->timeout)
@ -366,7 +366,7 @@ static int sg_io(struct file *file, struct request_queue *q,
*/
blk_execute_rq(q, bd_disk, rq, 0);
hdr->duration = ((jiffies - start_time) * 1000) / HZ;
hdr->duration = jiffies_to_msecs(jiffies - start_time);
return blk_complete_sghdr_rq(rq, hdr, bio);
out:

167
drivers/block/umem.c
View file

@ -34,7 +34,7 @@
* - set initialised bit then.
*/
//#define DEBUG /* uncomment if you want debugging info (pr_debug) */
#undef DEBUG /* #define DEBUG if you want debugging info (pr_debug) */
#include <linux/fs.h>
#include <linux/bio.h>
#include <linux/kernel.h>
@ -143,17 +143,12 @@ static struct cardinfo cards[MM_MAXCARDS];
static struct block_device_operations mm_fops;
static struct timer_list battery_timer;
static int num_cards = 0;
static int num_cards;
static struct gendisk *mm_gendisk[MM_MAXCARDS];
static void check_batteries(struct cardinfo *card);
/*
-----------------------------------------------------------------------------------
-- get_userbit
-----------------------------------------------------------------------------------
*/
static int get_userbit(struct cardinfo *card, int bit)
{
unsigned char led;
@ -161,11 +156,7 @@ static int get_userbit(struct cardinfo *card, int bit)
led = readb(card->csr_remap + MEMCTRLCMD_LEDCTRL);
return led & bit;
}
/*
-----------------------------------------------------------------------------------
-- set_userbit
-----------------------------------------------------------------------------------
*/
static int set_userbit(struct cardinfo *card, int bit, unsigned char state)
{
unsigned char led;
@ -179,11 +170,7 @@ static int set_userbit(struct cardinfo *card, int bit, unsigned char state)
return 0;
}
/*
-----------------------------------------------------------------------------------
-- set_led
-----------------------------------------------------------------------------------
*/
/*
* NOTE: For the power LED, use the LED_POWER_* macros since they differ
*/
@ -203,11 +190,6 @@ static void set_led(struct cardinfo *card, int shift, unsigned char state)
}
#ifdef MM_DIAG
/*
-----------------------------------------------------------------------------------
-- dump_regs
-----------------------------------------------------------------------------------
*/
static void dump_regs(struct cardinfo *card)
{
unsigned char *p;
@ -224,32 +206,28 @@ static void dump_regs(struct cardinfo *card)
}
}
#endif
/*
-----------------------------------------------------------------------------------
-- dump_dmastat
-----------------------------------------------------------------------------------
*/
static void dump_dmastat(struct cardinfo *card, unsigned int dmastat)
{
dev_printk(KERN_DEBUG, &card->dev->dev, "DMAstat - ");
if (dmastat & DMASCR_ANY_ERR)
printk("ANY_ERR ");
printk(KERN_CONT "ANY_ERR ");
if (dmastat & DMASCR_MBE_ERR)
printk("MBE_ERR ");
printk(KERN_CONT "MBE_ERR ");
if (dmastat & DMASCR_PARITY_ERR_REP)
printk("PARITY_ERR_REP ");
printk(KERN_CONT "PARITY_ERR_REP ");
if (dmastat & DMASCR_PARITY_ERR_DET)
printk("PARITY_ERR_DET ");
printk(KERN_CONT "PARITY_ERR_DET ");
if (dmastat & DMASCR_SYSTEM_ERR_SIG)
printk("SYSTEM_ERR_SIG ");
printk(KERN_CONT "SYSTEM_ERR_SIG ");
if (dmastat & DMASCR_TARGET_ABT)
printk("TARGET_ABT ");
printk(KERN_CONT "TARGET_ABT ");
if (dmastat & DMASCR_MASTER_ABT)
printk("MASTER_ABT ");
printk(KERN_CONT "MASTER_ABT ");
if (dmastat & DMASCR_CHAIN_COMPLETE)
printk("CHAIN_COMPLETE ");
printk(KERN_CONT "CHAIN_COMPLETE ");
if (dmastat & DMASCR_DMA_COMPLETE)
printk("DMA_COMPLETE ");
printk(KERN_CONT "DMA_COMPLETE ");
printk("\n");
}
@ -286,7 +264,8 @@ static void mm_start_io(struct cardinfo *card)
/* make the last descriptor end the chain */
page = &card->mm_pages[card->Active];
pr_debug("start_io: %d %d->%d\n", card->Active, page->headcnt, page->cnt-1);
pr_debug("start_io: %d %d->%d\n",
card->Active, page->headcnt, page->cnt - 1);
desc = &page->desc[page->cnt-1];
desc->control_bits |= cpu_to_le32(DMASCR_CHAIN_COMP_EN);
@ -455,8 +434,8 @@ static void process_page(unsigned long data)
/* check if any of the requests in the page are DMA_COMPLETE,
* and deal with them appropriately.
* If we find a descriptor without DMA_COMPLETE in the semaphore, then
* dma must have hit an error on that descriptor, so use dma_status instead
* and assume that all following descriptors must be re-tried.
* dma must have hit an error on that descriptor, so use dma_status
* instead and assume that all following descriptors must be re-tried.
*/
struct mm_page *page;
struct bio *return_bio = NULL;
@ -501,7 +480,8 @@ static void process_page(unsigned long data)
le32_to_cpu(desc->transfer_size));
dump_dmastat(card, control);
} else if (test_bit(BIO_RW, &bio->bi_rw) &&
le32_to_cpu(desc->local_addr)>>9 == card->init_size) {
le32_to_cpu(desc->local_addr) >> 9 ==
card->init_size) {
card->init_size += le32_to_cpu(desc->transfer_size) >> 9;
if (card->init_size >> 1 >= card->mm_size) {
dev_printk(KERN_INFO, &card->dev->dev,
@ -514,7 +494,8 @@ static void process_page(unsigned long data)
return_bio = bio;
}
if (last) break;
if (last)
break;
}
if (debug & DEBUG_LED_ON_TRANSFER)
@ -545,11 +526,6 @@ static void process_page(unsigned long data)
}
}
/*
-----------------------------------------------------------------------------------
-- mm_make_request
-----------------------------------------------------------------------------------
*/
static int mm_make_request(struct request_queue *q, struct bio *bio)
{
struct cardinfo *card = q->queuedata;
@ -566,11 +542,6 @@ static int mm_make_request(struct request_queue *q, struct bio *bio)
return 0;
}
/*
-----------------------------------------------------------------------------------
-- mm_interrupt
-----------------------------------------------------------------------------------
*/
static irqreturn_t mm_interrupt(int irq, void *__card)
{
struct cardinfo *card = (struct cardinfo *) __card;
@ -602,9 +573,12 @@ HW_TRACE(0x30);
stat = readb(card->csr_remap + MEMCTRLCMD_ERRSTATUS);
data_log1 = le32_to_cpu(readl(card->csr_remap + ERROR_DATA_LOG));
data_log2 = le32_to_cpu(readl(card->csr_remap + ERROR_DATA_LOG + 4));
addr_log1 = le32_to_cpu(readl(card->csr_remap + ERROR_ADDR_LOG));
data_log1 = le32_to_cpu(readl(card->csr_remap +
ERROR_DATA_LOG));
data_log2 = le32_to_cpu(readl(card->csr_remap +
ERROR_DATA_LOG + 4));
addr_log1 = le32_to_cpu(readl(card->csr_remap +
ERROR_ADDR_LOG));
addr_log2 = readb(card->csr_remap + ERROR_ADDR_LOG + 4);
count = readb(card->csr_remap + ERROR_COUNT);
@ -671,11 +645,7 @@ HW_TRACE(0x36);
return IRQ_HANDLED;
}
/*
-----------------------------------------------------------------------------------
-- set_fault_to_battery_status
-----------------------------------------------------------------------------------
*/
/*
* If both batteries are good, no LED
* If either battery has been warned, solid LED
@ -696,12 +666,6 @@ static void set_fault_to_battery_status(struct cardinfo *card)
static void init_battery_timer(void);
/*
-----------------------------------------------------------------------------------
-- check_battery
-----------------------------------------------------------------------------------
*/
static int check_battery(struct cardinfo *card, int battery, int status)
{
if (status != card->battery[battery].good) {
@ -730,11 +694,7 @@ static int check_battery(struct cardinfo *card, int battery, int status)
return 0;
}
/*
-----------------------------------------------------------------------------------
-- check_batteries
-----------------------------------------------------------------------------------
*/
static void check_batteries(struct cardinfo *card)
{
/* NOTE: this must *never* be called while the card
@ -775,11 +735,7 @@ static void check_all_batteries(unsigned long ptr)
init_battery_timer();
}
/*
-----------------------------------------------------------------------------------
-- init_battery_timer
-----------------------------------------------------------------------------------
*/
static void init_battery_timer(void)
{
init_timer(&battery_timer);
@ -787,20 +743,12 @@ static void init_battery_timer(void)
battery_timer.expires = jiffies + (HZ * 60);
add_timer(&battery_timer);
}
/*
-----------------------------------------------------------------------------------
-- del_battery_timer
-----------------------------------------------------------------------------------
*/
static void del_battery_timer(void)
{
del_timer(&battery_timer);
}
/*
-----------------------------------------------------------------------------------
-- mm_revalidate
-----------------------------------------------------------------------------------
*/
/*
* Note no locks taken out here. In a worst case scenario, we could drop
* a chunk of system memory. But that should never happen, since validation
@ -833,33 +781,23 @@ static int mm_getgeo(struct block_device *bdev, struct hd_geometry *geo)
}
/*
-----------------------------------------------------------------------------------
-- mm_check_change
-----------------------------------------------------------------------------------
Future support for removable devices
* Future support for removable devices
*/
static int mm_check_change(struct gendisk *disk)
{
/* struct cardinfo *dev = disk->private_data; */
return 0;
}
/*
-----------------------------------------------------------------------------------
-- mm_fops
-----------------------------------------------------------------------------------
*/
static struct block_device_operations mm_fops = {
.owner = THIS_MODULE,
.getgeo = mm_getgeo,
.revalidate_disk = mm_revalidate,
.media_changed = mm_check_change,
};
/*
-----------------------------------------------------------------------------------
-- mm_pci_probe
-----------------------------------------------------------------------------------
*/
static int __devinit mm_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
static int __devinit mm_pci_probe(struct pci_dev *dev,
const struct pci_device_id *id)
{
int ret = -ENODEV;
struct cardinfo *card = &cards[num_cards];
@ -929,7 +867,8 @@ static int __devinit mm_pci_probe(struct pci_dev *dev, const struct pci_device_i
break;
case 0x6155:
card->flags |= UM_FLAG_NO_BYTE_STATUS | UM_FLAG_NO_BATTREG | UM_FLAG_NO_BATT;
card->flags |= UM_FLAG_NO_BYTE_STATUS |
UM_FLAG_NO_BATTREG | UM_FLAG_NO_BATT;
magic_number = 0x99;
break;
@ -1013,9 +952,9 @@ static int __devinit mm_pci_probe(struct pci_dev *dev, const struct pci_device_i
dev_printk(KERN_INFO, &card->dev->dev,
"Size %d KB, Battery 1 %s (%s), Battery 2 %s (%s)\n",
card->mm_size,
(batt_status & BATTERY_1_DISABLED ? "Disabled" : "Enabled"),
batt_status & BATTERY_1_DISABLED ? "Disabled" : "Enabled",
card->battery[0].good ? "OK" : "FAILURE",
(batt_status & BATTERY_2_DISABLED ? "Disabled" : "Enabled"),
batt_status & BATTERY_2_DISABLED ? "Disabled" : "Enabled",
card->battery[1].good ? "OK" : "FAILURE");
set_fault_to_battery_status(card);
@ -1030,11 +969,11 @@ static int __devinit mm_pci_probe(struct pci_dev *dev, const struct pci_device_i
data = ~data;
data += 1;
if (request_irq(dev->irq, mm_interrupt, IRQF_SHARED, DRIVER_NAME, card)) {
if (request_irq(dev->irq, mm_interrupt, IRQF_SHARED, DRIVER_NAME,
card)) {
dev_printk(KERN_ERR, &card->dev->dev,
"Unable to allocate IRQ\n");
ret = -ENODEV;
goto failed_req_irq;
}
@ -1091,11 +1030,7 @@ static int __devinit mm_pci_probe(struct pci_dev *dev, const struct pci_device_i
return ret;
}
/*
-----------------------------------------------------------------------------------
-- mm_pci_remove
-----------------------------------------------------------------------------------
*/
static void mm_pci_remove(struct pci_dev *dev)
{
struct cardinfo *card = pci_get_drvdata(dev);
@ -1141,12 +1076,6 @@ static struct pci_driver mm_pci_driver = {
.remove = mm_pci_remove,
};
/*
-----------------------------------------------------------------------------------
-- mm_init
-----------------------------------------------------------------------------------
*/
static int __init mm_init(void)
{
int retval, i;
@ -1193,11 +1122,7 @@ out:
put_disk(mm_gendisk[i]);
return -ENOMEM;
}
/*
-----------------------------------------------------------------------------------
-- mm_cleanup
-----------------------------------------------------------------------------------
*/
static void __exit mm_cleanup(void)
{
int i;

2
include/linux/elevator.h
View file

@ -119,7 +119,7 @@ extern void elv_put_request(struct request_queue *, struct request *);
/*
* io scheduler registration
*/
extern int elv_register(struct elevator_type *);
extern void elv_register(struct elevator_type *);
extern void elv_unregister(struct elevator_type *);
/*