audio: a2220: remove compile warnings
[linux-3.10.git] / drivers / misc / hpilo.c
1 /*
2  * Driver for the HP iLO management processor.
3  *
4  * Copyright (C) 2008 Hewlett-Packard Development Company, L.P.
5  *      David Altobelli <david.altobelli@hp.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  */
11 #include <linux/kernel.h>
12 #include <linux/types.h>
13 #include <linux/module.h>
14 #include <linux/fs.h>
15 #include <linux/pci.h>
16 #include <linux/interrupt.h>
17 #include <linux/ioport.h>
18 #include <linux/device.h>
19 #include <linux/file.h>
20 #include <linux/cdev.h>
21 #include <linux/sched.h>
22 #include <linux/spinlock.h>
23 #include <linux/delay.h>
24 #include <linux/uaccess.h>
25 #include <linux/io.h>
26 #include <linux/wait.h>
27 #include <linux/poll.h>
28 #include <linux/slab.h>
29 #include "hpilo.h"
30
31 static struct class *ilo_class;
32 static unsigned int ilo_major;
33 static unsigned int max_ccb = 16;
34 static char ilo_hwdev[MAX_ILO_DEV];
35
36 static inline int get_entry_id(int entry)
37 {
38         return (entry & ENTRY_MASK_DESCRIPTOR) >> ENTRY_BITPOS_DESCRIPTOR;
39 }
40
41 static inline int get_entry_len(int entry)
42 {
43         return ((entry & ENTRY_MASK_QWORDS) >> ENTRY_BITPOS_QWORDS) << 3;
44 }
45
46 static inline int mk_entry(int id, int len)
47 {
48         int qlen = len & 7 ? (len >> 3) + 1 : len >> 3;
49         return id << ENTRY_BITPOS_DESCRIPTOR | qlen << ENTRY_BITPOS_QWORDS;
50 }
51
52 static inline int desc_mem_sz(int nr_entry)
53 {
54         return nr_entry << L2_QENTRY_SZ;
55 }
56
57 /*
58  * FIFO queues, shared with hardware.
59  *
60  * If a queue has empty slots, an entry is added to the queue tail,
61  * and that entry is marked as occupied.
62  * Entries can be dequeued from the head of the list, when the device
63  * has marked the entry as consumed.
64  *
65  * Returns true on successful queue/dequeue, false on failure.
66  */
67 static int fifo_enqueue(struct ilo_hwinfo *hw, char *fifobar, int entry)
68 {
69         struct fifo *fifo_q = FIFOBARTOHANDLE(fifobar);
70         unsigned long flags;
71         int ret = 0;
72
73         spin_lock_irqsave(&hw->fifo_lock, flags);
74         if (!(fifo_q->fifobar[(fifo_q->tail + 1) & fifo_q->imask]
75               & ENTRY_MASK_O)) {
76                 fifo_q->fifobar[fifo_q->tail & fifo_q->imask] |=
77                                 (entry & ENTRY_MASK_NOSTATE) | fifo_q->merge;
78                 fifo_q->tail += 1;
79                 ret = 1;
80         }
81         spin_unlock_irqrestore(&hw->fifo_lock, flags);
82
83         return ret;
84 }
85
86 static int fifo_dequeue(struct ilo_hwinfo *hw, char *fifobar, int *entry)
87 {
88         struct fifo *fifo_q = FIFOBARTOHANDLE(fifobar);
89         unsigned long flags;
90         int ret = 0;
91         u64 c;
92
93         spin_lock_irqsave(&hw->fifo_lock, flags);
94         c = fifo_q->fifobar[fifo_q->head & fifo_q->imask];
95         if (c & ENTRY_MASK_C) {
96                 if (entry)
97                         *entry = c & ENTRY_MASK_NOSTATE;
98
99                 fifo_q->fifobar[fifo_q->head & fifo_q->imask] =
100                                                         (c | ENTRY_MASK) + 1;
101                 fifo_q->head += 1;
102                 ret = 1;
103         }
104         spin_unlock_irqrestore(&hw->fifo_lock, flags);
105
106         return ret;
107 }
108
109 static int fifo_check_recv(struct ilo_hwinfo *hw, char *fifobar)
110 {
111         struct fifo *fifo_q = FIFOBARTOHANDLE(fifobar);
112         unsigned long flags;
113         int ret = 0;
114         u64 c;
115
116         spin_lock_irqsave(&hw->fifo_lock, flags);
117         c = fifo_q->fifobar[fifo_q->head & fifo_q->imask];
118         if (c & ENTRY_MASK_C)
119                 ret = 1;
120         spin_unlock_irqrestore(&hw->fifo_lock, flags);
121
122         return ret;
123 }
124
125 static int ilo_pkt_enqueue(struct ilo_hwinfo *hw, struct ccb *ccb,
126                            int dir, int id, int len)
127 {
128         char *fifobar;
129         int entry;
130
131         if (dir == SENDQ)
132                 fifobar = ccb->ccb_u1.send_fifobar;
133         else
134                 fifobar = ccb->ccb_u3.recv_fifobar;
135
136         entry = mk_entry(id, len);
137         return fifo_enqueue(hw, fifobar, entry);
138 }
139
140 static int ilo_pkt_dequeue(struct ilo_hwinfo *hw, struct ccb *ccb,
141                            int dir, int *id, int *len, void **pkt)
142 {
143         char *fifobar, *desc;
144         int entry = 0, pkt_id = 0;
145         int ret;
146
147         if (dir == SENDQ) {
148                 fifobar = ccb->ccb_u1.send_fifobar;
149                 desc = ccb->ccb_u2.send_desc;
150         } else {
151                 fifobar = ccb->ccb_u3.recv_fifobar;
152                 desc = ccb->ccb_u4.recv_desc;
153         }
154
155         ret = fifo_dequeue(hw, fifobar, &entry);
156         if (ret) {
157                 pkt_id = get_entry_id(entry);
158                 if (id)
159                         *id = pkt_id;
160                 if (len)
161                         *len = get_entry_len(entry);
162                 if (pkt)
163                         *pkt = (void *)(desc + desc_mem_sz(pkt_id));
164         }
165
166         return ret;
167 }
168
169 static int ilo_pkt_recv(struct ilo_hwinfo *hw, struct ccb *ccb)
170 {
171         char *fifobar = ccb->ccb_u3.recv_fifobar;
172
173         return fifo_check_recv(hw, fifobar);
174 }
175
176 static inline void doorbell_set(struct ccb *ccb)
177 {
178         iowrite8(1, ccb->ccb_u5.db_base);
179 }
180
181 static inline void doorbell_clr(struct ccb *ccb)
182 {
183         iowrite8(2, ccb->ccb_u5.db_base);
184 }
185
186 static inline int ctrl_set(int l2sz, int idxmask, int desclim)
187 {
188         int active = 0, go = 1;
189         return l2sz << CTRL_BITPOS_L2SZ |
190                idxmask << CTRL_BITPOS_FIFOINDEXMASK |
191                desclim << CTRL_BITPOS_DESCLIMIT |
192                active << CTRL_BITPOS_A |
193                go << CTRL_BITPOS_G;
194 }
195
196 static void ctrl_setup(struct ccb *ccb, int nr_desc, int l2desc_sz)
197 {
198         /* for simplicity, use the same parameters for send and recv ctrls */
199         ccb->send_ctrl = ctrl_set(l2desc_sz, nr_desc-1, nr_desc-1);
200         ccb->recv_ctrl = ctrl_set(l2desc_sz, nr_desc-1, nr_desc-1);
201 }
202
203 static inline int fifo_sz(int nr_entry)
204 {
205         /* size of a fifo is determined by the number of entries it contains */
206         return (nr_entry * sizeof(u64)) + FIFOHANDLESIZE;
207 }
208
209 static void fifo_setup(void *base_addr, int nr_entry)
210 {
211         struct fifo *fifo_q = base_addr;
212         int i;
213
214         /* set up an empty fifo */
215         fifo_q->head = 0;
216         fifo_q->tail = 0;
217         fifo_q->reset = 0;
218         fifo_q->nrents = nr_entry;
219         fifo_q->imask = nr_entry - 1;
220         fifo_q->merge = ENTRY_MASK_O;
221
222         for (i = 0; i < nr_entry; i++)
223                 fifo_q->fifobar[i] = 0;
224 }
225
226 static void ilo_ccb_close(struct pci_dev *pdev, struct ccb_data *data)
227 {
228         struct ccb *driver_ccb = &data->driver_ccb;
229         struct ccb __iomem *device_ccb = data->mapped_ccb;
230         int retries;
231
232         /* complicated dance to tell the hw we are stopping */
233         doorbell_clr(driver_ccb);
234         iowrite32(ioread32(&device_ccb->send_ctrl) & ~(1 << CTRL_BITPOS_G),
235                   &device_ccb->send_ctrl);
236         iowrite32(ioread32(&device_ccb->recv_ctrl) & ~(1 << CTRL_BITPOS_G),
237                   &device_ccb->recv_ctrl);
238
239         /* give iLO some time to process stop request */
240         for (retries = MAX_WAIT; retries > 0; retries--) {
241                 doorbell_set(driver_ccb);
242                 udelay(WAIT_TIME);
243                 if (!(ioread32(&device_ccb->send_ctrl) & (1 << CTRL_BITPOS_A))
244                     &&
245                     !(ioread32(&device_ccb->recv_ctrl) & (1 << CTRL_BITPOS_A)))
246                         break;
247         }
248         if (retries == 0)
249                 dev_err(&pdev->dev, "Closing, but controller still active\n");
250
251         /* clear the hw ccb */
252         memset_io(device_ccb, 0, sizeof(struct ccb));
253
254         /* free resources used to back send/recv queues */
255         pci_free_consistent(pdev, data->dma_size, data->dma_va, data->dma_pa);
256 }
257
258 static int ilo_ccb_setup(struct ilo_hwinfo *hw, struct ccb_data *data, int slot)
259 {
260         char *dma_va;
261         dma_addr_t dma_pa;
262         struct ccb *driver_ccb, *ilo_ccb;
263
264         driver_ccb = &data->driver_ccb;
265         ilo_ccb = &data->ilo_ccb;
266
267         data->dma_size = 2 * fifo_sz(NR_QENTRY) +
268                          2 * desc_mem_sz(NR_QENTRY) +
269                          ILO_START_ALIGN + ILO_CACHE_SZ;
270
271         data->dma_va = pci_alloc_consistent(hw->ilo_dev, data->dma_size,
272                                             &data->dma_pa);
273         if (!data->dma_va)
274                 return -ENOMEM;
275
276         dma_va = (char *)data->dma_va;
277         dma_pa = data->dma_pa;
278
279         memset(dma_va, 0, data->dma_size);
280
281         dma_va = (char *)roundup((unsigned long)dma_va, ILO_START_ALIGN);
282         dma_pa = roundup(dma_pa, ILO_START_ALIGN);
283
284         /*
285          * Create two ccb's, one with virt addrs, one with phys addrs.
286          * Copy the phys addr ccb to device shared mem.
287          */
288         ctrl_setup(driver_ccb, NR_QENTRY, L2_QENTRY_SZ);
289         ctrl_setup(ilo_ccb, NR_QENTRY, L2_QENTRY_SZ);
290
291         fifo_setup(dma_va, NR_QENTRY);
292         driver_ccb->ccb_u1.send_fifobar = dma_va + FIFOHANDLESIZE;
293         ilo_ccb->ccb_u1.send_fifobar_pa = dma_pa + FIFOHANDLESIZE;
294         dma_va += fifo_sz(NR_QENTRY);
295         dma_pa += fifo_sz(NR_QENTRY);
296
297         dma_va = (char *)roundup((unsigned long)dma_va, ILO_CACHE_SZ);
298         dma_pa = roundup(dma_pa, ILO_CACHE_SZ);
299
300         fifo_setup(dma_va, NR_QENTRY);
301         driver_ccb->ccb_u3.recv_fifobar = dma_va + FIFOHANDLESIZE;
302         ilo_ccb->ccb_u3.recv_fifobar_pa = dma_pa + FIFOHANDLESIZE;
303         dma_va += fifo_sz(NR_QENTRY);
304         dma_pa += fifo_sz(NR_QENTRY);
305
306         driver_ccb->ccb_u2.send_desc = dma_va;
307         ilo_ccb->ccb_u2.send_desc_pa = dma_pa;
308         dma_pa += desc_mem_sz(NR_QENTRY);
309         dma_va += desc_mem_sz(NR_QENTRY);
310
311         driver_ccb->ccb_u4.recv_desc = dma_va;
312         ilo_ccb->ccb_u4.recv_desc_pa = dma_pa;
313
314         driver_ccb->channel = slot;
315         ilo_ccb->channel = slot;
316
317         driver_ccb->ccb_u5.db_base = hw->db_vaddr + (slot << L2_DB_SIZE);
318         ilo_ccb->ccb_u5.db_base = NULL; /* hw ccb's doorbell is not used */
319
320         return 0;
321 }
322
323 static void ilo_ccb_open(struct ilo_hwinfo *hw, struct ccb_data *data, int slot)
324 {
325         int pkt_id, pkt_sz;
326         struct ccb *driver_ccb = &data->driver_ccb;
327
328         /* copy the ccb with physical addrs to device memory */
329         data->mapped_ccb = (struct ccb __iomem *)
330                                 (hw->ram_vaddr + (slot * ILOHW_CCB_SZ));
331         memcpy_toio(data->mapped_ccb, &data->ilo_ccb, sizeof(struct ccb));
332
333         /* put packets on the send and receive queues */
334         pkt_sz = 0;
335         for (pkt_id = 0; pkt_id < NR_QENTRY; pkt_id++) {
336                 ilo_pkt_enqueue(hw, driver_ccb, SENDQ, pkt_id, pkt_sz);
337                 doorbell_set(driver_ccb);
338         }
339
340         pkt_sz = desc_mem_sz(1);
341         for (pkt_id = 0; pkt_id < NR_QENTRY; pkt_id++)
342                 ilo_pkt_enqueue(hw, driver_ccb, RECVQ, pkt_id, pkt_sz);
343
344         /* the ccb is ready to use */
345         doorbell_clr(driver_ccb);
346 }
347
348 static int ilo_ccb_verify(struct ilo_hwinfo *hw, struct ccb_data *data)
349 {
350         int pkt_id, i;
351         struct ccb *driver_ccb = &data->driver_ccb;
352
353         /* make sure iLO is really handling requests */
354         for (i = MAX_WAIT; i > 0; i--) {
355                 if (ilo_pkt_dequeue(hw, driver_ccb, SENDQ, &pkt_id, NULL, NULL))
356                         break;
357                 udelay(WAIT_TIME);
358         }
359
360         if (i == 0) {
361                 dev_err(&hw->ilo_dev->dev, "Open could not dequeue a packet\n");
362                 return -EBUSY;
363         }
364
365         ilo_pkt_enqueue(hw, driver_ccb, SENDQ, pkt_id, 0);
366         doorbell_set(driver_ccb);
367         return 0;
368 }
369
370 static inline int is_channel_reset(struct ccb *ccb)
371 {
372         /* check for this particular channel needing a reset */
373         return FIFOBARTOHANDLE(ccb->ccb_u1.send_fifobar)->reset;
374 }
375
376 static inline void set_channel_reset(struct ccb *ccb)
377 {
378         /* set a flag indicating this channel needs a reset */
379         FIFOBARTOHANDLE(ccb->ccb_u1.send_fifobar)->reset = 1;
380 }
381
382 static inline int get_device_outbound(struct ilo_hwinfo *hw)
383 {
384         return ioread32(&hw->mmio_vaddr[DB_OUT]);
385 }
386
387 static inline int is_db_reset(int db_out)
388 {
389         return db_out & (1 << DB_RESET);
390 }
391
392 static inline int is_device_reset(struct ilo_hwinfo *hw)
393 {
394         /* check for global reset condition */
395         return is_db_reset(get_device_outbound(hw));
396 }
397
398 static inline void clear_pending_db(struct ilo_hwinfo *hw, int clr)
399 {
400         iowrite32(clr, &hw->mmio_vaddr[DB_OUT]);
401 }
402
403 static inline void clear_device(struct ilo_hwinfo *hw)
404 {
405         /* clear the device (reset bits, pending channel entries) */
406         clear_pending_db(hw, -1);
407 }
408
409 static inline void ilo_enable_interrupts(struct ilo_hwinfo *hw)
410 {
411         iowrite8(ioread8(&hw->mmio_vaddr[DB_IRQ]) | 1, &hw->mmio_vaddr[DB_IRQ]);
412 }
413
414 static inline void ilo_disable_interrupts(struct ilo_hwinfo *hw)
415 {
416         iowrite8(ioread8(&hw->mmio_vaddr[DB_IRQ]) & ~1,
417                  &hw->mmio_vaddr[DB_IRQ]);
418 }
419
420 static void ilo_set_reset(struct ilo_hwinfo *hw)
421 {
422         int slot;
423
424         /*
425          * Mapped memory is zeroed on ilo reset, so set a per ccb flag
426          * to indicate that this ccb needs to be closed and reopened.
427          */
428         for (slot = 0; slot < max_ccb; slot++) {
429                 if (!hw->ccb_alloc[slot])
430                         continue;
431                 set_channel_reset(&hw->ccb_alloc[slot]->driver_ccb);
432         }
433 }
434
435 static ssize_t ilo_read(struct file *fp, char __user *buf,
436                         size_t len, loff_t *off)
437 {
438         int err, found, cnt, pkt_id, pkt_len;
439         struct ccb_data *data = fp->private_data;
440         struct ccb *driver_ccb = &data->driver_ccb;
441         struct ilo_hwinfo *hw = data->ilo_hw;
442         void *pkt;
443
444         if (is_channel_reset(driver_ccb)) {
445                 /*
446                  * If the device has been reset, applications
447                  * need to close and reopen all ccbs.
448                  */
449                 return -ENODEV;
450         }
451
452         /*
453          * This function is to be called when data is expected
454          * in the channel, and will return an error if no packet is found
455          * during the loop below.  The sleep/retry logic is to allow
456          * applications to call read() immediately post write(),
457          * and give iLO some time to process the sent packet.
458          */
459         cnt = 20;
460         do {
461                 /* look for a received packet */
462                 found = ilo_pkt_dequeue(hw, driver_ccb, RECVQ, &pkt_id,
463                                         &pkt_len, &pkt);
464                 if (found)
465                         break;
466                 cnt--;
467                 msleep(100);
468         } while (!found && cnt);
469
470         if (!found)
471                 return -EAGAIN;
472
473         /* only copy the length of the received packet */
474         if (pkt_len < len)
475                 len = pkt_len;
476
477         err = copy_to_user(buf, pkt, len);
478
479         /* return the received packet to the queue */
480         ilo_pkt_enqueue(hw, driver_ccb, RECVQ, pkt_id, desc_mem_sz(1));
481
482         return err ? -EFAULT : len;
483 }
484
485 static ssize_t ilo_write(struct file *fp, const char __user *buf,
486                          size_t len, loff_t *off)
487 {
488         int err, pkt_id, pkt_len;
489         struct ccb_data *data = fp->private_data;
490         struct ccb *driver_ccb = &data->driver_ccb;
491         struct ilo_hwinfo *hw = data->ilo_hw;
492         void *pkt;
493
494         if (is_channel_reset(driver_ccb))
495                 return -ENODEV;
496
497         /* get a packet to send the user command */
498         if (!ilo_pkt_dequeue(hw, driver_ccb, SENDQ, &pkt_id, &pkt_len, &pkt))
499                 return -EBUSY;
500
501         /* limit the length to the length of the packet */
502         if (pkt_len < len)
503                 len = pkt_len;
504
505         /* on failure, set the len to 0 to return empty packet to the device */
506         err = copy_from_user(pkt, buf, len);
507         if (err)
508                 len = 0;
509
510         /* send the packet */
511         ilo_pkt_enqueue(hw, driver_ccb, SENDQ, pkt_id, len);
512         doorbell_set(driver_ccb);
513
514         return err ? -EFAULT : len;
515 }
516
517 static unsigned int ilo_poll(struct file *fp, poll_table *wait)
518 {
519         struct ccb_data *data = fp->private_data;
520         struct ccb *driver_ccb = &data->driver_ccb;
521
522         poll_wait(fp, &data->ccb_waitq, wait);
523
524         if (is_channel_reset(driver_ccb))
525                 return POLLERR;
526         else if (ilo_pkt_recv(data->ilo_hw, driver_ccb))
527                 return POLLIN | POLLRDNORM;
528
529         return 0;
530 }
531
532 static int ilo_close(struct inode *ip, struct file *fp)
533 {
534         int slot;
535         struct ccb_data *data;
536         struct ilo_hwinfo *hw;
537         unsigned long flags;
538
539         slot = iminor(ip) % max_ccb;
540         hw = container_of(ip->i_cdev, struct ilo_hwinfo, cdev);
541
542         spin_lock(&hw->open_lock);
543
544         if (hw->ccb_alloc[slot]->ccb_cnt == 1) {
545
546                 data = fp->private_data;
547
548                 spin_lock_irqsave(&hw->alloc_lock, flags);
549                 hw->ccb_alloc[slot] = NULL;
550                 spin_unlock_irqrestore(&hw->alloc_lock, flags);
551
552                 ilo_ccb_close(hw->ilo_dev, data);
553
554                 kfree(data);
555         } else
556                 hw->ccb_alloc[slot]->ccb_cnt--;
557
558         spin_unlock(&hw->open_lock);
559
560         return 0;
561 }
562
563 static int ilo_open(struct inode *ip, struct file *fp)
564 {
565         int slot, error;
566         struct ccb_data *data;
567         struct ilo_hwinfo *hw;
568         unsigned long flags;
569
570         slot = iminor(ip) % max_ccb;
571         hw = container_of(ip->i_cdev, struct ilo_hwinfo, cdev);
572
573         /* new ccb allocation */
574         data = kzalloc(sizeof(*data), GFP_KERNEL);
575         if (!data)
576                 return -ENOMEM;
577
578         spin_lock(&hw->open_lock);
579
580         /* each fd private_data holds sw/hw view of ccb */
581         if (hw->ccb_alloc[slot] == NULL) {
582                 /* create a channel control block for this minor */
583                 error = ilo_ccb_setup(hw, data, slot);
584                 if (error) {
585                         kfree(data);
586                         goto out;
587                 }
588
589                 data->ccb_cnt = 1;
590                 data->ccb_excl = fp->f_flags & O_EXCL;
591                 data->ilo_hw = hw;
592                 init_waitqueue_head(&data->ccb_waitq);
593
594                 /* write the ccb to hw */
595                 spin_lock_irqsave(&hw->alloc_lock, flags);
596                 ilo_ccb_open(hw, data, slot);
597                 hw->ccb_alloc[slot] = data;
598                 spin_unlock_irqrestore(&hw->alloc_lock, flags);
599
600                 /* make sure the channel is functional */
601                 error = ilo_ccb_verify(hw, data);
602                 if (error) {
603
604                         spin_lock_irqsave(&hw->alloc_lock, flags);
605                         hw->ccb_alloc[slot] = NULL;
606                         spin_unlock_irqrestore(&hw->alloc_lock, flags);
607
608                         ilo_ccb_close(hw->ilo_dev, data);
609
610                         kfree(data);
611                         goto out;
612                 }
613
614         } else {
615                 kfree(data);
616                 if (fp->f_flags & O_EXCL || hw->ccb_alloc[slot]->ccb_excl) {
617                         /*
618                          * The channel exists, and either this open
619                          * or a previous open of this channel wants
620                          * exclusive access.
621                          */
622                         error = -EBUSY;
623                 } else {
624                         hw->ccb_alloc[slot]->ccb_cnt++;
625                         error = 0;
626                 }
627         }
628 out:
629         spin_unlock(&hw->open_lock);
630
631         if (!error)
632                 fp->private_data = hw->ccb_alloc[slot];
633
634         return error;
635 }
636
637 static const struct file_operations ilo_fops = {
638         .owner          = THIS_MODULE,
639         .read           = ilo_read,
640         .write          = ilo_write,
641         .poll           = ilo_poll,
642         .open           = ilo_open,
643         .release        = ilo_close,
644         .llseek         = noop_llseek,
645 };
646
647 static irqreturn_t ilo_isr(int irq, void *data)
648 {
649         struct ilo_hwinfo *hw = data;
650         int pending, i;
651
652         spin_lock(&hw->alloc_lock);
653
654         /* check for ccbs which have data */
655         pending = get_device_outbound(hw);
656         if (!pending) {
657                 spin_unlock(&hw->alloc_lock);
658                 return IRQ_NONE;
659         }
660
661         if (is_db_reset(pending)) {
662                 /* wake up all ccbs if the device was reset */
663                 pending = -1;
664                 ilo_set_reset(hw);
665         }
666
667         for (i = 0; i < max_ccb; i++) {
668                 if (!hw->ccb_alloc[i])
669                         continue;
670                 if (pending & (1 << i))
671                         wake_up_interruptible(&hw->ccb_alloc[i]->ccb_waitq);
672         }
673
674         /* clear the device of the channels that have been handled */
675         clear_pending_db(hw, pending);
676
677         spin_unlock(&hw->alloc_lock);
678
679         return IRQ_HANDLED;
680 }
681
682 static void ilo_unmap_device(struct pci_dev *pdev, struct ilo_hwinfo *hw)
683 {
684         pci_iounmap(pdev, hw->db_vaddr);
685         pci_iounmap(pdev, hw->ram_vaddr);
686         pci_iounmap(pdev, hw->mmio_vaddr);
687 }
688
689 static int ilo_map_device(struct pci_dev *pdev, struct ilo_hwinfo *hw)
690 {
691         int error = -ENOMEM;
692
693         /* map the memory mapped i/o registers */
694         hw->mmio_vaddr = pci_iomap(pdev, 1, 0);
695         if (hw->mmio_vaddr == NULL) {
696                 dev_err(&pdev->dev, "Error mapping mmio\n");
697                 goto out;
698         }
699
700         /* map the adapter shared memory region */
701         hw->ram_vaddr = pci_iomap(pdev, 2, max_ccb * ILOHW_CCB_SZ);
702         if (hw->ram_vaddr == NULL) {
703                 dev_err(&pdev->dev, "Error mapping shared mem\n");
704                 goto mmio_free;
705         }
706
707         /* map the doorbell aperture */
708         hw->db_vaddr = pci_iomap(pdev, 3, max_ccb * ONE_DB_SIZE);
709         if (hw->db_vaddr == NULL) {
710                 dev_err(&pdev->dev, "Error mapping doorbell\n");
711                 goto ram_free;
712         }
713
714         return 0;
715 ram_free:
716         pci_iounmap(pdev, hw->ram_vaddr);
717 mmio_free:
718         pci_iounmap(pdev, hw->mmio_vaddr);
719 out:
720         return error;
721 }
722
723 static void ilo_remove(struct pci_dev *pdev)
724 {
725         int i, minor;
726         struct ilo_hwinfo *ilo_hw = pci_get_drvdata(pdev);
727
728         if (!ilo_hw)
729                 return;
730
731         clear_device(ilo_hw);
732
733         minor = MINOR(ilo_hw->cdev.dev);
734         for (i = minor; i < minor + max_ccb; i++)
735                 device_destroy(ilo_class, MKDEV(ilo_major, i));
736
737         cdev_del(&ilo_hw->cdev);
738         ilo_disable_interrupts(ilo_hw);
739         free_irq(pdev->irq, ilo_hw);
740         ilo_unmap_device(pdev, ilo_hw);
741         pci_release_regions(pdev);
742         /*
743          * pci_disable_device(pdev) used to be here. But this PCI device has
744          * two functions with interrupt lines connected to a single pin. The
745          * other one is a USB host controller. So when we disable the PIN here
746          * e.g. by rmmod hpilo, the controller stops working. It is because
747          * the interrupt link is disabled in ACPI since it is not refcounted
748          * yet. See acpi_pci_link_free_irq called from acpi_pci_irq_disable.
749          */
750         kfree(ilo_hw);
751         ilo_hwdev[(minor / max_ccb)] = 0;
752 }
753
754 static int ilo_probe(struct pci_dev *pdev,
755                                const struct pci_device_id *ent)
756 {
757         int devnum, minor, start, error = 0;
758         struct ilo_hwinfo *ilo_hw;
759
760         /* Ignore subsystem_device = 0x1979 (set by BIOS)  */
761         if (pdev->subsystem_device == 0x1979)
762                 return 0;
763
764         if (max_ccb > MAX_CCB)
765                 max_ccb = MAX_CCB;
766         else if (max_ccb < MIN_CCB)
767                 max_ccb = MIN_CCB;
768
769         /* find a free range for device files */
770         for (devnum = 0; devnum < MAX_ILO_DEV; devnum++) {
771                 if (ilo_hwdev[devnum] == 0) {
772                         ilo_hwdev[devnum] = 1;
773                         break;
774                 }
775         }
776
777         if (devnum == MAX_ILO_DEV) {
778                 dev_err(&pdev->dev, "Error finding free device\n");
779                 return -ENODEV;
780         }
781
782         /* track global allocations for this device */
783         error = -ENOMEM;
784         ilo_hw = kzalloc(sizeof(*ilo_hw), GFP_KERNEL);
785         if (!ilo_hw)
786                 goto out;
787
788         ilo_hw->ilo_dev = pdev;
789         spin_lock_init(&ilo_hw->alloc_lock);
790         spin_lock_init(&ilo_hw->fifo_lock);
791         spin_lock_init(&ilo_hw->open_lock);
792
793         error = pci_enable_device(pdev);
794         if (error)
795                 goto free;
796
797         pci_set_master(pdev);
798
799         error = pci_request_regions(pdev, ILO_NAME);
800         if (error)
801                 goto disable;
802
803         error = ilo_map_device(pdev, ilo_hw);
804         if (error)
805                 goto free_regions;
806
807         pci_set_drvdata(pdev, ilo_hw);
808         clear_device(ilo_hw);
809
810         error = request_irq(pdev->irq, ilo_isr, IRQF_SHARED, "hpilo", ilo_hw);
811         if (error)
812                 goto unmap;
813
814         ilo_enable_interrupts(ilo_hw);
815
816         cdev_init(&ilo_hw->cdev, &ilo_fops);
817         ilo_hw->cdev.owner = THIS_MODULE;
818         start = devnum * max_ccb;
819         error = cdev_add(&ilo_hw->cdev, MKDEV(ilo_major, start), max_ccb);
820         if (error) {
821                 dev_err(&pdev->dev, "Could not add cdev\n");
822                 goto remove_isr;
823         }
824
825         for (minor = 0 ; minor < max_ccb; minor++) {
826                 struct device *dev;
827                 dev = device_create(ilo_class, &pdev->dev,
828                                     MKDEV(ilo_major, minor), NULL,
829                                     "hpilo!d%dccb%d", devnum, minor);
830                 if (IS_ERR(dev))
831                         dev_err(&pdev->dev, "Could not create files\n");
832         }
833
834         return 0;
835 remove_isr:
836         ilo_disable_interrupts(ilo_hw);
837         free_irq(pdev->irq, ilo_hw);
838 unmap:
839         ilo_unmap_device(pdev, ilo_hw);
840 free_regions:
841         pci_release_regions(pdev);
842 disable:
843 /*      pci_disable_device(pdev);  see comment in ilo_remove */
844 free:
845         kfree(ilo_hw);
846 out:
847         ilo_hwdev[devnum] = 0;
848         return error;
849 }
850
851 static struct pci_device_id ilo_devices[] = {
852         { PCI_DEVICE(PCI_VENDOR_ID_COMPAQ, 0xB204) },
853         { PCI_DEVICE(PCI_VENDOR_ID_HP, 0x3307) },
854         { }
855 };
856 MODULE_DEVICE_TABLE(pci, ilo_devices);
857
858 static struct pci_driver ilo_driver = {
859         .name     = ILO_NAME,
860         .id_table = ilo_devices,
861         .probe    = ilo_probe,
862         .remove   = ilo_remove,
863 };
864
865 static int __init ilo_init(void)
866 {
867         int error;
868         dev_t dev;
869
870         ilo_class = class_create(THIS_MODULE, "iLO");
871         if (IS_ERR(ilo_class)) {
872                 error = PTR_ERR(ilo_class);
873                 goto out;
874         }
875
876         error = alloc_chrdev_region(&dev, 0, MAX_OPEN, ILO_NAME);
877         if (error)
878                 goto class_destroy;
879
880         ilo_major = MAJOR(dev);
881
882         error = pci_register_driver(&ilo_driver);
883         if (error)
884                 goto chr_remove;
885
886         return 0;
887 chr_remove:
888         unregister_chrdev_region(dev, MAX_OPEN);
889 class_destroy:
890         class_destroy(ilo_class);
891 out:
892         return error;
893 }
894
895 static void __exit ilo_exit(void)
896 {
897         pci_unregister_driver(&ilo_driver);
898         unregister_chrdev_region(MKDEV(ilo_major, 0), MAX_OPEN);
899         class_destroy(ilo_class);
900 }
901
902 MODULE_VERSION("1.4.1");
903 MODULE_ALIAS(ILO_NAME);
904 MODULE_DESCRIPTION(ILO_NAME);
905 MODULE_AUTHOR("David Altobelli <david.altobelli@hp.com>");
906 MODULE_LICENSE("GPL v2");
907
908 module_param(max_ccb, uint, 0444);
909 MODULE_PARM_DESC(max_ccb, "Maximum number of HP iLO channels to attach (16)");
910
911 module_init(ilo_init);
912 module_exit(ilo_exit);