Skip to content

L
linux
Commit 458cf5e9 authored by Randy Dunlap's avatar Randy Dunlap Committed by Jens Axboe
Browse files
Options

Cleanup umem driver: fix most checkpatch warnings, conform to kernel 

coding style.

  linux-2.6.24-rc5-git3> checkpatch.pl-next  patches/block-umem-ckpatch.patch
  total: 0 errors, 5 warnings, 530 lines checked

All of these are line-length warnings.

Only change in generated object file is due to not initializing a
static global variable to 0.
Signed-off-by: default avatarRandy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: default avatarJens Axboe <jens.axboe@oracle.com>
parent 2fdd82bd
Show whitespace changes
Inline Side-by-side
Showing with 81 additions and 156 deletions
drivers/block/umem.c
View file @ 458cf5e9
......@@ -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);
......@@ -310,8 +289,8 @@ static void mm_start_io(struct cardinfo *card)
writel(0, card->csr_remap + DMA_SEMAPHORE_ADDR);
writel(0, card->csr_remap + DMA_SEMAPHORE_ADDR + 4);
offset = ((char*)desc) - ((char*)page->desc);
writel(cpu_to_le32((page->page_dma+offset)&0xffffffff),
offset = ((char *)desc) - ((char *)page->desc);
writel(cpu_to_le32((page->page_dma+offset) & 0xffffffff),
card->csr_remap + DMA_DESCRIPTOR_ADDR);
/* Force the value to u64 before shifting otherwise >> 32 is undefined C
* and on some ports will do nothing ! */
......@@ -352,7 +331,7 @@ static inline void reset_page(struct mm_page *page)
page->cnt = 0;
page->headcnt = 0;
page->bio = NULL;
page->biotail = & page->bio;
page->biotail = &page->bio;
}
static void mm_unplug_device(struct request_queue *q)
......@@ -408,7 +387,7 @@ static int add_bio(struct cardinfo *card)
vec->bv_page,
vec->bv_offset,
len,
(rw==READ) ?
(rw == READ) ?
PCI_DMA_FROMDEVICE : PCI_DMA_TODEVICE);
p = &card->mm_pages[card->Ready];
......@@ -427,10 +406,10 @@ static int add_bio(struct cardinfo *card)
desc->pci_addr = cpu_to_le64((u64)desc->data_dma_handle);
desc->local_addr = cpu_to_le64(card->current_sector << 9);
desc->transfer_size = cpu_to_le32(len);
offset = ( ((char*)&desc->sem_control_bits) - ((char*)p->desc));
offset = (((char *)&desc->sem_control_bits) - ((char *)p->desc));
desc->sem_addr = cpu_to_le64((u64)(p->page_dma+offset));
desc->zero1 = desc->zero2 = 0;
offset = ( ((char*)(desc+1)) - ((char*)p->desc));
offset = (((char *)(desc+1)) - ((char *)p->desc));
desc->next_desc_addr = cpu_to_le64(p->page_dma+offset);
desc->control_bits = cpu_to_le32(DMASCR_GO|DMASCR_ERR_INT_EN|
DMASCR_PARITY_INT_EN|
......@@ -455,11 +434,11 @@ 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;
struct bio *return_bio = NULL;
struct cardinfo *card = (struct cardinfo *)data;
unsigned int dma_status = card->dma_status;
......@@ -472,12 +451,12 @@ static void process_page(unsigned long data)
struct bio *bio = page->bio;
struct mm_dma_desc *desc = &page->desc[page->headcnt];
int control = le32_to_cpu(desc->sem_control_bits);
int last=0;
int last = 0;
int idx;
if (!(control & DMASCR_DMA_COMPLETE)) {
control = dma_status;
last=1;
last = 1;
}
page->headcnt++;
idx = page->idx;
......@@ -489,8 +468,8 @@ static void process_page(unsigned long data)
}
pci_unmap_page(card->dev, desc->data_dma_handle,
bio_iovec_idx(bio,idx)->bv_len,
(control& DMASCR_TRANSFER_READ) ?
bio_iovec_idx(bio, idx)->bv_len,
(control & DMASCR_TRANSFER_READ) ?
PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
if (control & DMASCR_HARD_ERROR) {
/* error */
......@@ -501,9 +480,10 @@ 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) {
card->init_size += le32_to_cpu(desc->transfer_size)>>9;
if (card->init_size>>1 >= card->mm_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,
"memory now initialised\n");
set_userbit(card, MEMORY_INITIALIZED, 1);
......@@ -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)
......@@ -536,7 +517,7 @@ static void process_page(unsigned long data)
out_unlock:
spin_unlock_bh(&card->lock);
while(return_bio) {
while (return_bio) {
struct bio *bio = return_bio;
return_bio = bio->bi_next;
......@@ -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;
......@@ -589,10 +560,10 @@ HW_TRACE(0x30);
/* clear COMPLETION interrupts */
if (card->flags & UM_FLAG_NO_BYTE_STATUS)
writel(cpu_to_le32(DMASCR_DMA_COMPLETE|DMASCR_CHAIN_COMPLETE),
card->csr_remap+ DMA_STATUS_CTRL);
card->csr_remap + DMA_STATUS_CTRL);
else
writeb((DMASCR_DMA_COMPLETE|DMASCR_CHAIN_COMPLETE) >> 16,
card->csr_remap+ DMA_STATUS_CTRL + 2);
card->csr_remap + DMA_STATUS_CTRL + 2);
/* log errors and clear interrupt status */
if (dma_status & DMASCR_ANY_ERR) {
......@@ -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,
.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];
......@@ -917,7 +855,7 @@ static int __devinit mm_pci_probe(struct pci_dev *dev, const struct pci_device_i
"CSR 0x%08lx -> 0x%p (0x%lx)\n",
csr_base, card->csr_remap, csr_len);
switch(card->dev->device) {
switch (card->dev->device) {
case 0x5415:
card->flags |= UM_FLAG_NO_BYTE_STATUS | UM_FLAG_NO_BATTREG;
magic_number = 0x59;
......@@ -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;
......@@ -945,10 +884,10 @@ static int __devinit mm_pci_probe(struct pci_dev *dev, const struct pci_device_i
}
card->mm_pages[0].desc = pci_alloc_consistent(card->dev,
PAGE_SIZE*2,
PAGE_SIZE * 2,
&card->mm_pages[0].page_dma);
card->mm_pages[1].desc = pci_alloc_consistent(card->dev,
PAGE_SIZE*2,
PAGE_SIZE * 2,
&card->mm_pages[1].page_dma);
if (card->mm_pages[0].desc == NULL ||
card->mm_pages[1].desc == NULL) {
......@@ -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);
......@@ -1119,16 +1054,16 @@ static void mm_pci_remove(struct pci_dev *dev)
}
static const struct pci_device_id mm_pci_ids[] = {
{PCI_DEVICE(PCI_VENDOR_ID_MICRO_MEMORY,PCI_DEVICE_ID_MICRO_MEMORY_5415CN)},
{PCI_DEVICE(PCI_VENDOR_ID_MICRO_MEMORY,PCI_DEVICE_ID_MICRO_MEMORY_5425CN)},
{PCI_DEVICE(PCI_VENDOR_ID_MICRO_MEMORY,PCI_DEVICE_ID_MICRO_MEMORY_6155)},
{PCI_DEVICE(PCI_VENDOR_ID_MICRO_MEMORY, PCI_DEVICE_ID_MICRO_MEMORY_5415CN)},
{PCI_DEVICE(PCI_VENDOR_ID_MICRO_MEMORY, PCI_DEVICE_ID_MICRO_MEMORY_5425CN)},
{PCI_DEVICE(PCI_VENDOR_ID_MICRO_MEMORY, PCI_DEVICE_ID_MICRO_MEMORY_6155)},
{
.vendor = 0x8086,
.device = 0xB555,
.subvendor= 0x1332,
.subdevice= 0x5460,
.subvendor = 0x1332,
.subdevice = 0x5460,
.class = 0x050000,
.class_mask= 0,
.class_mask = 0,
}, { /* end: all zeroes */ }
};
......@@ -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,18 +1122,14 @@ static int __init mm_init(void)
put_disk(mm_gendisk[i]);
return -ENOMEM;
}
/*
-----------------------------------------------------------------------------------
-- mm_cleanup
-----------------------------------------------------------------------------------
*/
static void __exit mm_cleanup(void)
{
int i;
del_battery_timer();
for (i=0; i < num_cards ; i++) {
for (i = 0; i < num_cards ; i++) {
del_gendisk(mm_gendisk[i]);
put_disk(mm_gendisk[i]);
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7