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