1 // SPDX-License-Identifier: GPL-2.0 2 /* 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 28 static const struct class ilo_class = { 29 .name = "iLO", 30 }; 31 static unsigned int ilo_major; 32 static unsigned int max_ccb = 16; 33 static char ilo_hwdev[MAX_ILO_DEV]; 34 static 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 42 static inline int get_entry_id(int entry) 43 { 44 return (entry & ENTRY_MASK_DESCRIPTOR) >> ENTRY_BITPOS_DESCRIPTOR; 45 } 46 47 static inline int get_entry_len(int entry) 48 { 49 return ((entry & ENTRY_MASK_QWORDS) >> ENTRY_BITPOS_QWORDS) << 3; 50 } 51 52 static 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 58 static 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 device 69 * has marked the entry as consumed. 70 * 71 * Returns true on successful queue/dequeue, false on failure. 72 */ 73 static 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 92 static 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 115 static 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 131 static 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 else 140 fifobar = ccb->ccb_u3.recv_fifobar; 141 142 entry = mk_entry(id, len); 143 return fifo_enqueue(hw, fifobar, entry); 144 } 145 146 static 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 175 static 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 182 static inline void doorbell_set(struct ccb *ccb) 183 { 184 iowrite8(1, ccb->ccb_u5.db_base); 185 } 186 187 static inline void doorbell_clr(struct ccb *ccb) 188 { 189 iowrite8(2, ccb->ccb_u5.db_base); 190 } 191 192 static 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 202 static 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 209 static 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 215 static 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 232 static 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 265 static 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 328 static 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 353 static 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 375 static 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 381 static 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 387 static inline int get_device_outbound(struct ilo_hwinfo *hw) 388 { 389 return ioread32(&hw->mmio_vaddr[DB_OUT]); 390 } 391 392 static inline int is_db_reset(int db_out) 393 { 394 return db_out & (1 << DB_RESET); 395 } 396 397 static inline void clear_pending_db(struct ilo_hwinfo *hw, int clr) 398 { 399 iowrite32(clr, &hw->mmio_vaddr[DB_OUT]); 400 } 401 402 static 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 408 static 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 413 static 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 419 static 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 flag 425 * 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 434 static 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, applications 446 * need to close and reopen all ccbs. 447 */ 448 return -ENODEV; 449 } 450 451 /* 452 * This function is to be called when data is expected 453 * in the channel, and will return an error if no packet is found 454 * during the loop below. The sleep/retry logic is to allow 455 * 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 484 static 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 516 static __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 531 static 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 } else 555 hw->ccb_alloc[slot]->ccb_cnt--; 556 557 spin_unlock(&hw->open_lock); 558 559 return 0; 560 } 561 562 static 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 open 618 * or a previous open of this channel wants 619 * exclusive access. 620 */ 621 error = -EBUSY; 622 } else { 623 hw->ccb_alloc[slot]->ccb_cnt++; 624 error = 0; 625 } 626 } 627 out: 628 spin_unlock(&hw->open_lock); 629 630 if (!error) 631 fp->private_data = hw->ccb_alloc[slot]; 632 633 return error; 634 } 635 636 static 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 646 static 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 681 static 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 688 static 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; 731 ram_free: 732 pci_iounmap(pdev, hw->ram_vaddr); 733 mmio_free: 734 pci_iounmap(pdev, hw->mmio_vaddr); 735 out: 736 return -ENOMEM; 737 } 738 739 static 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 has 760 * two functions with interrupt lines connected to a single pin. The 761 * other one is a USB host controller. So when we disable the PIN here 762 * e.g. by rmmod hpilo, the controller stops working. It is because 763 * the interrupt link is disabled in ACPI since it is not refcounted 764 * 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 770 static 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; 852 remove_isr: 853 ilo_disable_interrupts(ilo_hw); 854 free_irq(pdev->irq, ilo_hw); 855 unmap: 856 ilo_unmap_device(pdev, ilo_hw); 857 free_regions: 858 pci_release_regions(pdev); 859 disable: 860 /* pci_disable_device(pdev); see comment in ilo_remove */ 861 free: 862 kfree(ilo_hw); 863 out: 864 ilo_hwdev[devnum] = 0; 865 return error; 866 } 867 868 static 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 }; 873 MODULE_DEVICE_TABLE(pci, ilo_devices); 874 875 static struct pci_driver ilo_driver = { 876 .name = ILO_NAME, 877 .id_table = ilo_devices, 878 .probe = ilo_probe, 879 .remove = ilo_remove, 880 }; 881 882 static 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; 902 chr_remove: 903 unregister_chrdev_region(dev, MAX_OPEN); 904 class_destroy: 905 class_unregister(&ilo_class); 906 out: 907 return error; 908 } 909 910 static 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 917 MODULE_VERSION("1.5.0"); 918 MODULE_ALIAS(ILO_NAME); 919 MODULE_DESCRIPTION(ILO_NAME); 920 MODULE_AUTHOR("David Altobelli <david.altobelli@hpe.com>"); 921 MODULE_LICENSE("GPL v2"); 922 923 module_param(max_ccb, uint, 0444); 924 MODULE_PARM_DESC(max_ccb, "Maximum number of HP iLO channels to attach (8-24)(default=16)"); 925 926 module_init(ilo_init); 927 module_exit(ilo_exit); 928