xref: /openbmc/linux/drivers/misc/hpilo.c (revision fd06978b)
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 
get_entry_id(int entry)42 static inline int get_entry_id(int entry)
43 {
44 	return (entry & ENTRY_MASK_DESCRIPTOR) >> ENTRY_BITPOS_DESCRIPTOR;
45 }
46 
get_entry_len(int entry)47 static inline int get_entry_len(int entry)
48 {
49 	return ((entry & ENTRY_MASK_QWORDS) >> ENTRY_BITPOS_QWORDS) << 3;
50 }
51 
mk_entry(int id,int len)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 
desc_mem_sz(int nr_entry)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  */
fifo_enqueue(struct ilo_hwinfo * hw,char * fifobar,int entry)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 
fifo_dequeue(struct ilo_hwinfo * hw,char * fifobar,int * entry)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 
fifo_check_recv(struct ilo_hwinfo * hw,char * fifobar)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 
ilo_pkt_enqueue(struct ilo_hwinfo * hw,struct ccb * ccb,int dir,int id,int len)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 
ilo_pkt_dequeue(struct ilo_hwinfo * hw,struct ccb * ccb,int dir,int * id,int * len,void ** pkt)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 
ilo_pkt_recv(struct ilo_hwinfo * hw,struct ccb * ccb)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 
doorbell_set(struct ccb * ccb)182 static inline void doorbell_set(struct ccb *ccb)
183 {
184 	iowrite8(1, ccb->ccb_u5.db_base);
185 }
186 
doorbell_clr(struct ccb * ccb)187 static inline void doorbell_clr(struct ccb *ccb)
188 {
189 	iowrite8(2, ccb->ccb_u5.db_base);
190 }
191 
ctrl_set(int l2sz,int idxmask,int desclim)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 
ctrl_setup(struct ccb * ccb,int nr_desc,int l2desc_sz)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 
fifo_sz(int nr_entry)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 
fifo_setup(void * base_addr,int nr_entry)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 
ilo_ccb_close(struct pci_dev * pdev,struct ccb_data * data)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 
ilo_ccb_setup(struct ilo_hwinfo * hw,struct ccb_data * data,int slot)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 
ilo_ccb_open(struct ilo_hwinfo * hw,struct ccb_data * data,int slot)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 
ilo_ccb_verify(struct ilo_hwinfo * hw,struct ccb_data * data)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 
is_channel_reset(struct ccb * ccb)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 
set_channel_reset(struct ccb * ccb)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 
get_device_outbound(struct ilo_hwinfo * hw)387 static inline int get_device_outbound(struct ilo_hwinfo *hw)
388 {
389 	return ioread32(&hw->mmio_vaddr[DB_OUT]);
390 }
391 
is_db_reset(int db_out)392 static inline int is_db_reset(int db_out)
393 {
394 	return db_out & (1 << DB_RESET);
395 }
396 
clear_pending_db(struct ilo_hwinfo * hw,int clr)397 static inline void clear_pending_db(struct ilo_hwinfo *hw, int clr)
398 {
399 	iowrite32(clr, &hw->mmio_vaddr[DB_OUT]);
400 }
401 
clear_device(struct ilo_hwinfo * hw)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 
ilo_enable_interrupts(struct ilo_hwinfo * hw)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 
ilo_disable_interrupts(struct ilo_hwinfo * hw)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 
ilo_set_reset(struct ilo_hwinfo * hw)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 
ilo_read(struct file * fp,char __user * buf,size_t len,loff_t * off)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 
ilo_write(struct file * fp,const char __user * buf,size_t len,loff_t * off)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 
ilo_poll(struct file * fp,poll_table * wait)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 
ilo_close(struct inode * ip,struct file * fp)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 
ilo_open(struct inode * ip,struct file * fp)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 
ilo_isr(int irq,void * data)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 
ilo_unmap_device(struct pci_dev * pdev,struct ilo_hwinfo * hw)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 
ilo_map_device(struct pci_dev * pdev,struct ilo_hwinfo * hw)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 
ilo_remove(struct pci_dev * pdev)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 
ilo_probe(struct pci_dev * pdev,const struct pci_device_id * ent)770 static int ilo_probe(struct pci_dev *pdev,
771 			       const struct pci_device_id *ent)
772 {
773 	int devnum, minor, 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 (minor = 0 ; minor < max_ccb; minor++) {
843 		struct device *dev;
844 		dev = device_create(&ilo_class, &pdev->dev,
845 				    MKDEV(ilo_major, minor), NULL,
846 				    "hpilo!d%dccb%d", devnum, minor);
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 
ilo_init(void)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 
ilo_exit(void)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