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