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(lock: &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(lock: &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(lock: &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: &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(nr_entry: 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(l2sz: l2desc_sz, idxmask: nr_desc-1, desclim: nr_desc-1); |
206 | ccb->recv_ctrl = ctrl_set(l2sz: l2desc_sz, idxmask: nr_desc-1, desclim: 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(ccb: 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(ccb: 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(dev: &pdev->dev, size: data->dma_size, cpu_addr: data->dma_va, |
262 | dma_handle: 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(dev: &hw->ilo_dev->dev, size: data->dma_size, |
279 | dma_handle: &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(ccb: driver_ccb, NR_QENTRY, L2_QENTRY_SZ); |
294 | ctrl_setup(ccb: ilo_ccb, NR_QENTRY, L2_QENTRY_SZ); |
295 | |
296 | fifo_setup(base_addr: 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(base_addr: 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, ccb: driver_ccb, SENDQ, id: pkt_id, len: pkt_sz); |
342 | doorbell_set(ccb: driver_ccb); |
343 | } |
344 | |
345 | pkt_sz = desc_mem_sz(nr_entry: 1); |
346 | for (pkt_id = 0; pkt_id < NR_QENTRY; pkt_id++) |
347 | ilo_pkt_enqueue(hw, ccb: driver_ccb, RECVQ, id: pkt_id, len: pkt_sz); |
348 | |
349 | /* the ccb is ready to use */ |
350 | doorbell_clr(ccb: 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, ccb: driver_ccb, SENDQ, id: &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, ccb: driver_ccb, SENDQ, id: pkt_id, len: 0); |
371 | doorbell_set(ccb: 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, clr: -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(ccb: 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, ccb: driver_ccb, RECVQ, id: &pkt_id, |
462 | len: &pkt_len, pkt: &pkt); |
463 | if (found) |
464 | break; |
465 | cnt--; |
466 | msleep(msecs: 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(to: buf, from: pkt, n: len); |
477 | |
478 | /* return the received packet to the queue */ |
479 | ilo_pkt_enqueue(hw, ccb: driver_ccb, RECVQ, id: pkt_id, len: desc_mem_sz(nr_entry: 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(ccb: driver_ccb)) |
494 | return -ENODEV; |
495 | |
496 | /* get a packet to send the user command */ |
497 | if (!ilo_pkt_dequeue(hw, ccb: driver_ccb, SENDQ, id: &pkt_id, len: &pkt_len, pkt: &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(to: pkt, from: buf, n: len); |
506 | if (err) |
507 | len = 0; |
508 | |
509 | /* send the packet */ |
510 | ilo_pkt_enqueue(hw, ccb: driver_ccb, SENDQ, id: pkt_id, len); |
511 | doorbell_set(ccb: 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(filp: fp, wait_address: &data->ccb_waitq, p: wait); |
522 | |
523 | if (is_channel_reset(ccb: driver_ccb)) |
524 | return EPOLLERR; |
525 | else if (ilo_pkt_recv(hw: data->ilo_hw, ccb: 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(inode: ip) % max_ccb; |
539 | hw = container_of(ip->i_cdev, struct ilo_hwinfo, cdev); |
540 | |
541 | spin_lock(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(lock: &hw->alloc_lock, flags); |
550 | |
551 | ilo_ccb_close(pdev: hw->ilo_dev, data); |
552 | |
553 | kfree(objp: data); |
554 | } else |
555 | hw->ccb_alloc[slot]->ccb_cnt--; |
556 | |
557 | spin_unlock(lock: &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(inode: ip) % max_ccb; |
570 | hw = container_of(ip->i_cdev, struct ilo_hwinfo, cdev); |
571 | |
572 | /* new ccb allocation */ |
573 | data = kzalloc(size: sizeof(*data), GFP_KERNEL); |
574 | if (!data) |
575 | return -ENOMEM; |
576 | |
577 | spin_lock(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(objp: 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(lock: &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(lock: &hw->alloc_lock, flags); |
606 | |
607 | ilo_ccb_close(pdev: hw->ilo_dev, data); |
608 | |
609 | kfree(objp: data); |
610 | goto out; |
611 | } |
612 | |
613 | } else { |
614 | kfree(objp: 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(lock: &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(lock: &hw->alloc_lock); |
652 | |
653 | /* check for ccbs which have data */ |
654 | pending = get_device_outbound(hw); |
655 | if (!pending) { |
656 | spin_unlock(lock: &hw->alloc_lock); |
657 | return IRQ_NONE; |
658 | } |
659 | |
660 | if (is_db_reset(db_out: 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, clr: pending); |
675 | |
676 | spin_unlock(lock: &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(dev: pdev, hw->db_vaddr); |
684 | pci_iounmap(dev: pdev, hw->ram_vaddr); |
685 | pci_iounmap(dev: 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(dev: pdev, bar: 1, max: 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(dev: pdev, PCI_REVISION_ID, val: &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(dev: pdev, bar, offset: off, maxlen: 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(dev: pdev, bar: 3, max: 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(dev: pdev, hw->ram_vaddr); |
733 | mmio_free: |
734 | pci_iounmap(dev: 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(hw: ilo_hw); |
748 | |
749 | minor = MINOR(ilo_hw->cdev.dev); |
750 | for (i = minor; i < minor + max_ccb; i++) |
751 | device_destroy(cls: &ilo_class, MKDEV(ilo_major, i)); |
752 | |
753 | cdev_del(&ilo_hw->cdev); |
754 | ilo_disable_interrupts(hw: ilo_hw); |
755 | free_irq(pdev->irq, ilo_hw); |
756 | ilo_unmap_device(pdev, hw: 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(objp: 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(ids: ilo_blacklist, dev: 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(size: 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(dev: pdev); |
811 | if (error) |
812 | goto free; |
813 | |
814 | pci_set_master(dev: pdev); |
815 | |
816 | error = pci_request_regions(pdev, ILO_NAME); |
817 | if (error) |
818 | goto disable; |
819 | |
820 | error = ilo_map_device(pdev, hw: ilo_hw); |
821 | if (error) |
822 | goto free_regions; |
823 | |
824 | pci_set_drvdata(pdev, data: ilo_hw); |
825 | clear_device(hw: ilo_hw); |
826 | |
827 | error = request_irq(irq: pdev->irq, handler: ilo_isr, IRQF_SHARED, name: "hpilo" , dev: ilo_hw); |
828 | if (error) |
829 | goto unmap; |
830 | |
831 | ilo_enable_interrupts(hw: 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(cls: &ilo_class, parent: &pdev->dev, |
845 | MKDEV(ilo_major, start + slot), NULL, |
846 | fmt: "hpilo!d%dccb%d" , devnum, slot); |
847 | if (IS_ERR(ptr: dev)) |
848 | dev_err(&pdev->dev, "Could not create files\n" ); |
849 | } |
850 | |
851 | return 0; |
852 | remove_isr: |
853 | ilo_disable_interrupts(hw: ilo_hw); |
854 | free_irq(pdev->irq, ilo_hw); |
855 | unmap: |
856 | ilo_unmap_device(pdev, hw: 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(objp: 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(class: &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(class: &ilo_class); |
906 | out: |
907 | return error; |
908 | } |
909 | |
910 | static void __exit ilo_exit(void) |
911 | { |
912 | pci_unregister_driver(dev: &ilo_driver); |
913 | unregister_chrdev_region(MKDEV(ilo_major, 0), MAX_OPEN); |
914 | class_unregister(class: &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 | |