7e2026894e9f278c5751551005e2ff7b8a4c3a3f
[muen/linux.git] / drivers / misc / mei / hw-txe.c
1 /*
2  *
3  * Intel Management Engine Interface (Intel MEI) Linux driver
4  * Copyright (c) 2013-2014, Intel Corporation.
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms and conditions of the GNU General Public License,
8  * version 2, as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13  * more details.
14  *
15  */
16
17 #include <linux/pci.h>
18 #include <linux/jiffies.h>
19 #include <linux/ktime.h>
20 #include <linux/delay.h>
21 #include <linux/kthread.h>
22 #include <linux/interrupt.h>
23 #include <linux/pm_runtime.h>
24
25 #include <linux/mei.h>
26
27 #include "mei_dev.h"
28 #include "hw-txe.h"
29 #include "client.h"
30 #include "hbm.h"
31
32 #include "mei-trace.h"
33
34 #define TXE_HBUF_DEPTH (PAYLOAD_SIZE / MEI_SLOT_SIZE)
35
36 /**
37  * mei_txe_reg_read - Reads 32bit data from the txe device
38  *
39  * @base_addr: registers base address
40  * @offset: register offset
41  *
42  * Return: register value
43  */
44 static inline u32 mei_txe_reg_read(void __iomem *base_addr,
45                                         unsigned long offset)
46 {
47         return ioread32(base_addr + offset);
48 }
49
50 /**
51  * mei_txe_reg_write - Writes 32bit data to the txe device
52  *
53  * @base_addr: registers base address
54  * @offset: register offset
55  * @value: the value to write
56  */
57 static inline void mei_txe_reg_write(void __iomem *base_addr,
58                                 unsigned long offset, u32 value)
59 {
60         iowrite32(value, base_addr + offset);
61 }
62
63 /**
64  * mei_txe_sec_reg_read_silent - Reads 32bit data from the SeC BAR
65  *
66  * @hw: the txe hardware structure
67  * @offset: register offset
68  *
69  * Doesn't check for aliveness while Reads 32bit data from the SeC BAR
70  *
71  * Return: register value
72  */
73 static inline u32 mei_txe_sec_reg_read_silent(struct mei_txe_hw *hw,
74                                 unsigned long offset)
75 {
76         return mei_txe_reg_read(hw->mem_addr[SEC_BAR], offset);
77 }
78
79 /**
80  * mei_txe_sec_reg_read - Reads 32bit data from the SeC BAR
81  *
82  * @hw: the txe hardware structure
83  * @offset: register offset
84  *
85  * Reads 32bit data from the SeC BAR and shout loud if aliveness is not set
86  *
87  * Return: register value
88  */
89 static inline u32 mei_txe_sec_reg_read(struct mei_txe_hw *hw,
90                                 unsigned long offset)
91 {
92         WARN(!hw->aliveness, "sec read: aliveness not asserted\n");
93         return mei_txe_sec_reg_read_silent(hw, offset);
94 }
95 /**
96  * mei_txe_sec_reg_write_silent - Writes 32bit data to the SeC BAR
97  *   doesn't check for aliveness
98  *
99  * @hw: the txe hardware structure
100  * @offset: register offset
101  * @value: value to write
102  *
103  * Doesn't check for aliveness while writes 32bit data from to the SeC BAR
104  */
105 static inline void mei_txe_sec_reg_write_silent(struct mei_txe_hw *hw,
106                                 unsigned long offset, u32 value)
107 {
108         mei_txe_reg_write(hw->mem_addr[SEC_BAR], offset, value);
109 }
110
111 /**
112  * mei_txe_sec_reg_write - Writes 32bit data to the SeC BAR
113  *
114  * @hw: the txe hardware structure
115  * @offset: register offset
116  * @value: value to write
117  *
118  * Writes 32bit data from the SeC BAR and shout loud if aliveness is not set
119  */
120 static inline void mei_txe_sec_reg_write(struct mei_txe_hw *hw,
121                                 unsigned long offset, u32 value)
122 {
123         WARN(!hw->aliveness, "sec write: aliveness not asserted\n");
124         mei_txe_sec_reg_write_silent(hw, offset, value);
125 }
126 /**
127  * mei_txe_br_reg_read - Reads 32bit data from the Bridge BAR
128  *
129  * @hw: the txe hardware structure
130  * @offset: offset from which to read the data
131  *
132  * Return: the byte read.
133  */
134 static inline u32 mei_txe_br_reg_read(struct mei_txe_hw *hw,
135                                 unsigned long offset)
136 {
137         return mei_txe_reg_read(hw->mem_addr[BRIDGE_BAR], offset);
138 }
139
140 /**
141  * mei_txe_br_reg_write - Writes 32bit data to the Bridge BAR
142  *
143  * @hw: the txe hardware structure
144  * @offset: offset from which to write the data
145  * @value: the byte to write
146  */
147 static inline void mei_txe_br_reg_write(struct mei_txe_hw *hw,
148                                 unsigned long offset, u32 value)
149 {
150         mei_txe_reg_write(hw->mem_addr[BRIDGE_BAR], offset, value);
151 }
152
153 /**
154  * mei_txe_aliveness_set - request for aliveness change
155  *
156  * @dev: the device structure
157  * @req: requested aliveness value
158  *
159  * Request for aliveness change and returns true if the change is
160  *   really needed and false if aliveness is already
161  *   in the requested state
162  *
163  * Locking: called under "dev->device_lock" lock
164  *
165  * Return: true if request was send
166  */
167 static bool mei_txe_aliveness_set(struct mei_device *dev, u32 req)
168 {
169
170         struct mei_txe_hw *hw = to_txe_hw(dev);
171         bool do_req = hw->aliveness != req;
172
173         dev_dbg(dev->dev, "Aliveness current=%d request=%d\n",
174                                 hw->aliveness, req);
175         if (do_req) {
176                 dev->pg_event = MEI_PG_EVENT_WAIT;
177                 mei_txe_br_reg_write(hw, SICR_HOST_ALIVENESS_REQ_REG, req);
178         }
179         return do_req;
180 }
181
182
183 /**
184  * mei_txe_aliveness_req_get - get aliveness requested register value
185  *
186  * @dev: the device structure
187  *
188  * Extract HICR_HOST_ALIVENESS_RESP_ACK bit from
189  * from HICR_HOST_ALIVENESS_REQ register value
190  *
191  * Return: SICR_HOST_ALIVENESS_REQ_REQUESTED bit value
192  */
193 static u32 mei_txe_aliveness_req_get(struct mei_device *dev)
194 {
195         struct mei_txe_hw *hw = to_txe_hw(dev);
196         u32 reg;
197
198         reg = mei_txe_br_reg_read(hw, SICR_HOST_ALIVENESS_REQ_REG);
199         return reg & SICR_HOST_ALIVENESS_REQ_REQUESTED;
200 }
201
202 /**
203  * mei_txe_aliveness_get - get aliveness response register value
204  *
205  * @dev: the device structure
206  *
207  * Return: HICR_HOST_ALIVENESS_RESP_ACK bit from HICR_HOST_ALIVENESS_RESP
208  *         register
209  */
210 static u32 mei_txe_aliveness_get(struct mei_device *dev)
211 {
212         struct mei_txe_hw *hw = to_txe_hw(dev);
213         u32 reg;
214
215         reg = mei_txe_br_reg_read(hw, HICR_HOST_ALIVENESS_RESP_REG);
216         return reg & HICR_HOST_ALIVENESS_RESP_ACK;
217 }
218
219 /**
220  * mei_txe_aliveness_poll - waits for aliveness to settle
221  *
222  * @dev: the device structure
223  * @expected: expected aliveness value
224  *
225  * Polls for HICR_HOST_ALIVENESS_RESP.ALIVENESS_RESP to be set
226  *
227  * Return: 0 if the expected value was received, -ETIME otherwise
228  */
229 static int mei_txe_aliveness_poll(struct mei_device *dev, u32 expected)
230 {
231         struct mei_txe_hw *hw = to_txe_hw(dev);
232         ktime_t stop, start;
233
234         start = ktime_get();
235         stop = ktime_add(start, ms_to_ktime(SEC_ALIVENESS_WAIT_TIMEOUT));
236         do {
237                 hw->aliveness = mei_txe_aliveness_get(dev);
238                 if (hw->aliveness == expected) {
239                         dev->pg_event = MEI_PG_EVENT_IDLE;
240                         dev_dbg(dev->dev, "aliveness settled after %lld usecs\n",
241                                 ktime_to_us(ktime_sub(ktime_get(), start)));
242                         return 0;
243                 }
244                 usleep_range(20, 50);
245         } while (ktime_before(ktime_get(), stop));
246
247         dev->pg_event = MEI_PG_EVENT_IDLE;
248         dev_err(dev->dev, "aliveness timed out\n");
249         return -ETIME;
250 }
251
252 /**
253  * mei_txe_aliveness_wait - waits for aliveness to settle
254  *
255  * @dev: the device structure
256  * @expected: expected aliveness value
257  *
258  * Waits for HICR_HOST_ALIVENESS_RESP.ALIVENESS_RESP to be set
259  *
260  * Return: 0 on success and < 0 otherwise
261  */
262 static int mei_txe_aliveness_wait(struct mei_device *dev, u32 expected)
263 {
264         struct mei_txe_hw *hw = to_txe_hw(dev);
265         const unsigned long timeout =
266                         msecs_to_jiffies(SEC_ALIVENESS_WAIT_TIMEOUT);
267         long err;
268         int ret;
269
270         hw->aliveness = mei_txe_aliveness_get(dev);
271         if (hw->aliveness == expected)
272                 return 0;
273
274         mutex_unlock(&dev->device_lock);
275         err = wait_event_timeout(hw->wait_aliveness_resp,
276                         dev->pg_event == MEI_PG_EVENT_RECEIVED, timeout);
277         mutex_lock(&dev->device_lock);
278
279         hw->aliveness = mei_txe_aliveness_get(dev);
280         ret = hw->aliveness == expected ? 0 : -ETIME;
281
282         if (ret)
283                 dev_warn(dev->dev, "aliveness timed out = %ld aliveness = %d event = %d\n",
284                         err, hw->aliveness, dev->pg_event);
285         else
286                 dev_dbg(dev->dev, "aliveness settled after = %d msec aliveness = %d event = %d\n",
287                         jiffies_to_msecs(timeout - err),
288                         hw->aliveness, dev->pg_event);
289
290         dev->pg_event = MEI_PG_EVENT_IDLE;
291         return ret;
292 }
293
294 /**
295  * mei_txe_aliveness_set_sync - sets an wait for aliveness to complete
296  *
297  * @dev: the device structure
298  * @req: requested aliveness value
299  *
300  * Return: 0 on success and < 0 otherwise
301  */
302 int mei_txe_aliveness_set_sync(struct mei_device *dev, u32 req)
303 {
304         if (mei_txe_aliveness_set(dev, req))
305                 return mei_txe_aliveness_wait(dev, req);
306         return 0;
307 }
308
309 /**
310  * mei_txe_pg_in_transition - is device now in pg transition
311  *
312  * @dev: the device structure
313  *
314  * Return: true if in pg transition, false otherwise
315  */
316 static bool mei_txe_pg_in_transition(struct mei_device *dev)
317 {
318         return dev->pg_event == MEI_PG_EVENT_WAIT;
319 }
320
321 /**
322  * mei_txe_pg_is_enabled - detect if PG is supported by HW
323  *
324  * @dev: the device structure
325  *
326  * Return: true is pg supported, false otherwise
327  */
328 static bool mei_txe_pg_is_enabled(struct mei_device *dev)
329 {
330         return true;
331 }
332
333 /**
334  * mei_txe_pg_state  - translate aliveness register value
335  *   to the mei power gating state
336  *
337  * @dev: the device structure
338  *
339  * Return: MEI_PG_OFF if aliveness is on and MEI_PG_ON otherwise
340  */
341 static inline enum mei_pg_state mei_txe_pg_state(struct mei_device *dev)
342 {
343         struct mei_txe_hw *hw = to_txe_hw(dev);
344
345         return hw->aliveness ? MEI_PG_OFF : MEI_PG_ON;
346 }
347
348 /**
349  * mei_txe_input_ready_interrupt_enable - sets the Input Ready Interrupt
350  *
351  * @dev: the device structure
352  */
353 static void mei_txe_input_ready_interrupt_enable(struct mei_device *dev)
354 {
355         struct mei_txe_hw *hw = to_txe_hw(dev);
356         u32 hintmsk;
357         /* Enable the SEC_IPC_HOST_INT_MASK_IN_RDY interrupt */
358         hintmsk = mei_txe_sec_reg_read(hw, SEC_IPC_HOST_INT_MASK_REG);
359         hintmsk |= SEC_IPC_HOST_INT_MASK_IN_RDY;
360         mei_txe_sec_reg_write(hw, SEC_IPC_HOST_INT_MASK_REG, hintmsk);
361 }
362
363 /**
364  * mei_txe_input_doorbell_set - sets bit 0 in
365  *    SEC_IPC_INPUT_DOORBELL.IPC_INPUT_DOORBELL.
366  *
367  * @hw: the txe hardware structure
368  */
369 static void mei_txe_input_doorbell_set(struct mei_txe_hw *hw)
370 {
371         /* Clear the interrupt cause */
372         clear_bit(TXE_INTR_IN_READY_BIT, &hw->intr_cause);
373         mei_txe_sec_reg_write(hw, SEC_IPC_INPUT_DOORBELL_REG, 1);
374 }
375
376 /**
377  * mei_txe_output_ready_set - Sets the SICR_SEC_IPC_OUTPUT_STATUS bit to 1
378  *
379  * @hw: the txe hardware structure
380  */
381 static void mei_txe_output_ready_set(struct mei_txe_hw *hw)
382 {
383         mei_txe_br_reg_write(hw,
384                         SICR_SEC_IPC_OUTPUT_STATUS_REG,
385                         SEC_IPC_OUTPUT_STATUS_RDY);
386 }
387
388 /**
389  * mei_txe_is_input_ready - check if TXE is ready for receiving data
390  *
391  * @dev: the device structure
392  *
393  * Return: true if INPUT STATUS READY bit is set
394  */
395 static bool mei_txe_is_input_ready(struct mei_device *dev)
396 {
397         struct mei_txe_hw *hw = to_txe_hw(dev);
398         u32 status;
399
400         status = mei_txe_sec_reg_read(hw, SEC_IPC_INPUT_STATUS_REG);
401         return !!(SEC_IPC_INPUT_STATUS_RDY & status);
402 }
403
404 /**
405  * mei_txe_intr_clear - clear all interrupts
406  *
407  * @dev: the device structure
408  */
409 static inline void mei_txe_intr_clear(struct mei_device *dev)
410 {
411         struct mei_txe_hw *hw = to_txe_hw(dev);
412
413         mei_txe_sec_reg_write_silent(hw, SEC_IPC_HOST_INT_STATUS_REG,
414                 SEC_IPC_HOST_INT_STATUS_PENDING);
415         mei_txe_br_reg_write(hw, HISR_REG, HISR_INT_STS_MSK);
416         mei_txe_br_reg_write(hw, HHISR_REG, IPC_HHIER_MSK);
417 }
418
419 /**
420  * mei_txe_intr_disable - disable all interrupts
421  *
422  * @dev: the device structure
423  */
424 static void mei_txe_intr_disable(struct mei_device *dev)
425 {
426         struct mei_txe_hw *hw = to_txe_hw(dev);
427
428         mei_txe_br_reg_write(hw, HHIER_REG, 0);
429         mei_txe_br_reg_write(hw, HIER_REG, 0);
430 }
431 /**
432  * mei_txe_intr_enable - enable all interrupts
433  *
434  * @dev: the device structure
435  */
436 static void mei_txe_intr_enable(struct mei_device *dev)
437 {
438         struct mei_txe_hw *hw = to_txe_hw(dev);
439
440         mei_txe_br_reg_write(hw, HHIER_REG, IPC_HHIER_MSK);
441         mei_txe_br_reg_write(hw, HIER_REG, HIER_INT_EN_MSK);
442 }
443
444 /**
445  * mei_txe_synchronize_irq - wait for pending IRQ handlers
446  *
447  * @dev: the device structure
448  */
449 static void mei_txe_synchronize_irq(struct mei_device *dev)
450 {
451         struct pci_dev *pdev = to_pci_dev(dev->dev);
452
453         synchronize_irq(pdev->irq);
454 }
455
456 /**
457  * mei_txe_pending_interrupts - check if there are pending interrupts
458  *      only Aliveness, Input ready, and output doorbell are of relevance
459  *
460  * @dev: the device structure
461  *
462  * Checks if there are pending interrupts
463  * only Aliveness, Readiness, Input ready, and Output doorbell are relevant
464  *
465  * Return: true if there are pending interrupts
466  */
467 static bool mei_txe_pending_interrupts(struct mei_device *dev)
468 {
469
470         struct mei_txe_hw *hw = to_txe_hw(dev);
471         bool ret = (hw->intr_cause & (TXE_INTR_READINESS |
472                                       TXE_INTR_ALIVENESS |
473                                       TXE_INTR_IN_READY  |
474                                       TXE_INTR_OUT_DB));
475
476         if (ret) {
477                 dev_dbg(dev->dev,
478                         "Pending Interrupts InReady=%01d Readiness=%01d, Aliveness=%01d, OutDoor=%01d\n",
479                         !!(hw->intr_cause & TXE_INTR_IN_READY),
480                         !!(hw->intr_cause & TXE_INTR_READINESS),
481                         !!(hw->intr_cause & TXE_INTR_ALIVENESS),
482                         !!(hw->intr_cause & TXE_INTR_OUT_DB));
483         }
484         return ret;
485 }
486
487 /**
488  * mei_txe_input_payload_write - write a dword to the host buffer
489  *      at offset idx
490  *
491  * @dev: the device structure
492  * @idx: index in the host buffer
493  * @value: value
494  */
495 static void mei_txe_input_payload_write(struct mei_device *dev,
496                         unsigned long idx, u32 value)
497 {
498         struct mei_txe_hw *hw = to_txe_hw(dev);
499
500         mei_txe_sec_reg_write(hw, SEC_IPC_INPUT_PAYLOAD_REG +
501                         (idx * sizeof(u32)), value);
502 }
503
504 /**
505  * mei_txe_out_data_read - read dword from the device buffer
506  *      at offset idx
507  *
508  * @dev: the device structure
509  * @idx: index in the device buffer
510  *
511  * Return: register value at index
512  */
513 static u32 mei_txe_out_data_read(const struct mei_device *dev,
514                                         unsigned long idx)
515 {
516         struct mei_txe_hw *hw = to_txe_hw(dev);
517
518         return mei_txe_br_reg_read(hw,
519                 BRIDGE_IPC_OUTPUT_PAYLOAD_REG + (idx * sizeof(u32)));
520 }
521
522 /* Readiness */
523
524 /**
525  * mei_txe_readiness_set_host_rdy - set host readiness bit
526  *
527  * @dev: the device structure
528  */
529 static void mei_txe_readiness_set_host_rdy(struct mei_device *dev)
530 {
531         struct mei_txe_hw *hw = to_txe_hw(dev);
532
533         mei_txe_br_reg_write(hw,
534                 SICR_HOST_IPC_READINESS_REQ_REG,
535                 SICR_HOST_IPC_READINESS_HOST_RDY);
536 }
537
538 /**
539  * mei_txe_readiness_clear - clear host readiness bit
540  *
541  * @dev: the device structure
542  */
543 static void mei_txe_readiness_clear(struct mei_device *dev)
544 {
545         struct mei_txe_hw *hw = to_txe_hw(dev);
546
547         mei_txe_br_reg_write(hw, SICR_HOST_IPC_READINESS_REQ_REG,
548                                 SICR_HOST_IPC_READINESS_RDY_CLR);
549 }
550 /**
551  * mei_txe_readiness_get - Reads and returns
552  *      the HICR_SEC_IPC_READINESS register value
553  *
554  * @dev: the device structure
555  *
556  * Return: the HICR_SEC_IPC_READINESS register value
557  */
558 static u32 mei_txe_readiness_get(struct mei_device *dev)
559 {
560         struct mei_txe_hw *hw = to_txe_hw(dev);
561
562         return mei_txe_br_reg_read(hw, HICR_SEC_IPC_READINESS_REG);
563 }
564
565
566 /**
567  * mei_txe_readiness_is_sec_rdy - check readiness
568  *  for HICR_SEC_IPC_READINESS_SEC_RDY
569  *
570  * @readiness: cached readiness state
571  *
572  * Return: true if readiness bit is set
573  */
574 static inline bool mei_txe_readiness_is_sec_rdy(u32 readiness)
575 {
576         return !!(readiness & HICR_SEC_IPC_READINESS_SEC_RDY);
577 }
578
579 /**
580  * mei_txe_hw_is_ready - check if the hw is ready
581  *
582  * @dev: the device structure
583  *
584  * Return: true if sec is ready
585  */
586 static bool mei_txe_hw_is_ready(struct mei_device *dev)
587 {
588         u32 readiness =  mei_txe_readiness_get(dev);
589
590         return mei_txe_readiness_is_sec_rdy(readiness);
591 }
592
593 /**
594  * mei_txe_host_is_ready - check if the host is ready
595  *
596  * @dev: the device structure
597  *
598  * Return: true if host is ready
599  */
600 static inline bool mei_txe_host_is_ready(struct mei_device *dev)
601 {
602         struct mei_txe_hw *hw = to_txe_hw(dev);
603         u32 reg = mei_txe_br_reg_read(hw, HICR_SEC_IPC_READINESS_REG);
604
605         return !!(reg & HICR_SEC_IPC_READINESS_HOST_RDY);
606 }
607
608 /**
609  * mei_txe_readiness_wait - wait till readiness settles
610  *
611  * @dev: the device structure
612  *
613  * Return: 0 on success and -ETIME on timeout
614  */
615 static int mei_txe_readiness_wait(struct mei_device *dev)
616 {
617         if (mei_txe_hw_is_ready(dev))
618                 return 0;
619
620         mutex_unlock(&dev->device_lock);
621         wait_event_timeout(dev->wait_hw_ready, dev->recvd_hw_ready,
622                         msecs_to_jiffies(SEC_RESET_WAIT_TIMEOUT));
623         mutex_lock(&dev->device_lock);
624         if (!dev->recvd_hw_ready) {
625                 dev_err(dev->dev, "wait for readiness failed\n");
626                 return -ETIME;
627         }
628
629         dev->recvd_hw_ready = false;
630         return 0;
631 }
632
633 static const struct mei_fw_status mei_txe_fw_sts = {
634         .count = 2,
635         .status[0] = PCI_CFG_TXE_FW_STS0,
636         .status[1] = PCI_CFG_TXE_FW_STS1
637 };
638
639 /**
640  * mei_txe_fw_status - read fw status register from pci config space
641  *
642  * @dev: mei device
643  * @fw_status: fw status register values
644  *
645  * Return: 0 on success, error otherwise
646  */
647 static int mei_txe_fw_status(struct mei_device *dev,
648                              struct mei_fw_status *fw_status)
649 {
650         const struct mei_fw_status *fw_src = &mei_txe_fw_sts;
651         struct pci_dev *pdev = to_pci_dev(dev->dev);
652         int ret;
653         int i;
654
655         if (!fw_status)
656                 return -EINVAL;
657
658         fw_status->count = fw_src->count;
659         for (i = 0; i < fw_src->count && i < MEI_FW_STATUS_MAX; i++) {
660                 ret = pci_read_config_dword(pdev, fw_src->status[i],
661                                             &fw_status->status[i]);
662                 trace_mei_pci_cfg_read(dev->dev, "PCI_CFG_HSF_X",
663                                        fw_src->status[i],
664                                        fw_status->status[i]);
665                 if (ret)
666                         return ret;
667         }
668
669         return 0;
670 }
671
672 /**
673  *  mei_txe_hw_config - configure hardware at the start of the devices
674  *
675  * @dev: the device structure
676  *
677  * Configure hardware at the start of the device should be done only
678  *   once at the device probe time
679  */
680 static void mei_txe_hw_config(struct mei_device *dev)
681 {
682
683         struct mei_txe_hw *hw = to_txe_hw(dev);
684
685         hw->aliveness = mei_txe_aliveness_get(dev);
686         hw->readiness = mei_txe_readiness_get(dev);
687
688         dev_dbg(dev->dev, "aliveness_resp = 0x%08x, readiness = 0x%08x.\n",
689                 hw->aliveness, hw->readiness);
690 }
691
692
693 /**
694  * mei_txe_write - writes a message to device.
695  *
696  * @dev: the device structure
697  * @header: header of message
698  * @buf: message buffer will be written
699  *
700  * Return: 0 if success, <0 - otherwise.
701  */
702
703 static int mei_txe_write(struct mei_device *dev,
704                          struct mei_msg_hdr *header,
705                          const unsigned char *buf)
706 {
707         struct mei_txe_hw *hw = to_txe_hw(dev);
708         unsigned long rem;
709         unsigned long length;
710         unsigned long i;
711         u32 slots = TXE_HBUF_DEPTH;
712         u32 *reg_buf = (u32 *)buf;
713         u32 dw_cnt;
714
715         if (WARN_ON(!header || !buf))
716                 return -EINVAL;
717
718         length = header->length;
719
720         dev_dbg(dev->dev, MEI_HDR_FMT, MEI_HDR_PRM(header));
721
722         dw_cnt = mei_data2slots(length);
723         if (dw_cnt > slots)
724                 return -EMSGSIZE;
725
726         if (WARN(!hw->aliveness, "txe write: aliveness not asserted\n"))
727                 return -EAGAIN;
728
729         /* Enable Input Ready Interrupt. */
730         mei_txe_input_ready_interrupt_enable(dev);
731
732         if (!mei_txe_is_input_ready(dev)) {
733                 char fw_sts_str[MEI_FW_STATUS_STR_SZ];
734
735                 mei_fw_status_str(dev, fw_sts_str, MEI_FW_STATUS_STR_SZ);
736                 dev_err(dev->dev, "Input is not ready %s\n", fw_sts_str);
737                 return -EAGAIN;
738         }
739
740         mei_txe_input_payload_write(dev, 0, *((u32 *)header));
741
742         for (i = 0; i < length / 4; i++)
743                 mei_txe_input_payload_write(dev, i + 1, reg_buf[i]);
744
745         rem = length & 0x3;
746         if (rem > 0) {
747                 u32 reg = 0;
748
749                 memcpy(&reg, &buf[length - rem], rem);
750                 mei_txe_input_payload_write(dev, i + 1, reg);
751         }
752
753         /* after each write the whole buffer is consumed */
754         hw->slots = 0;
755
756         /* Set Input-Doorbell */
757         mei_txe_input_doorbell_set(hw);
758
759         return 0;
760 }
761
762 /**
763  * mei_txe_hbuf_depth - mimics the me hbuf circular buffer
764  *
765  * @dev: the device structure
766  *
767  * Return: the TXE_HBUF_DEPTH
768  */
769 static u32 mei_txe_hbuf_depth(const struct mei_device *dev)
770 {
771         return TXE_HBUF_DEPTH;
772 }
773
774 /**
775  * mei_txe_hbuf_empty_slots - mimics the me hbuf circular buffer
776  *
777  * @dev: the device structure
778  *
779  * Return: always TXE_HBUF_DEPTH
780  */
781 static int mei_txe_hbuf_empty_slots(struct mei_device *dev)
782 {
783         struct mei_txe_hw *hw = to_txe_hw(dev);
784
785         return hw->slots;
786 }
787
788 /**
789  * mei_txe_count_full_read_slots - mimics the me device circular buffer
790  *
791  * @dev: the device structure
792  *
793  * Return: always buffer size in dwords count
794  */
795 static int mei_txe_count_full_read_slots(struct mei_device *dev)
796 {
797         /* read buffers has static size */
798         return TXE_HBUF_DEPTH;
799 }
800
801 /**
802  * mei_txe_read_hdr - read message header which is always in 4 first bytes
803  *
804  * @dev: the device structure
805  *
806  * Return: mei message header
807  */
808
809 static u32 mei_txe_read_hdr(const struct mei_device *dev)
810 {
811         return mei_txe_out_data_read(dev, 0);
812 }
813 /**
814  * mei_txe_read - reads a message from the txe device.
815  *
816  * @dev: the device structure
817  * @buf: message buffer will be written
818  * @len: message size will be read
819  *
820  * Return: -EINVAL on error wrong argument and 0 on success
821  */
822 static int mei_txe_read(struct mei_device *dev,
823                 unsigned char *buf, unsigned long len)
824 {
825
826         struct mei_txe_hw *hw = to_txe_hw(dev);
827         u32 *reg_buf, reg;
828         u32 rem;
829         u32 i;
830
831         if (WARN_ON(!buf || !len))
832                 return -EINVAL;
833
834         reg_buf = (u32 *)buf;
835         rem = len & 0x3;
836
837         dev_dbg(dev->dev, "buffer-length = %lu buf[0]0x%08X\n",
838                 len, mei_txe_out_data_read(dev, 0));
839
840         for (i = 0; i < len / MEI_SLOT_SIZE; i++) {
841                 /* skip header: index starts from 1 */
842                 reg = mei_txe_out_data_read(dev, i + 1);
843                 dev_dbg(dev->dev, "buf[%d] = 0x%08X\n", i, reg);
844                 *reg_buf++ = reg;
845         }
846
847         if (rem) {
848                 reg = mei_txe_out_data_read(dev, i + 1);
849                 memcpy(reg_buf, &reg, rem);
850         }
851
852         mei_txe_output_ready_set(hw);
853         return 0;
854 }
855
856 /**
857  * mei_txe_hw_reset - resets host and fw.
858  *
859  * @dev: the device structure
860  * @intr_enable: if interrupt should be enabled after reset.
861  *
862  * Return: 0 on success and < 0 in case of error
863  */
864 static int mei_txe_hw_reset(struct mei_device *dev, bool intr_enable)
865 {
866         struct mei_txe_hw *hw = to_txe_hw(dev);
867
868         u32 aliveness_req;
869         /*
870          * read input doorbell to ensure consistency between  Bridge and SeC
871          * return value might be garbage return
872          */
873         (void)mei_txe_sec_reg_read_silent(hw, SEC_IPC_INPUT_DOORBELL_REG);
874
875         aliveness_req = mei_txe_aliveness_req_get(dev);
876         hw->aliveness = mei_txe_aliveness_get(dev);
877
878         /* Disable interrupts in this stage we will poll */
879         mei_txe_intr_disable(dev);
880
881         /*
882          * If Aliveness Request and Aliveness Response are not equal then
883          * wait for them to be equal
884          * Since we might have interrupts disabled - poll for it
885          */
886         if (aliveness_req != hw->aliveness)
887                 if (mei_txe_aliveness_poll(dev, aliveness_req) < 0) {
888                         dev_err(dev->dev, "wait for aliveness settle failed ... bailing out\n");
889                         return -EIO;
890                 }
891
892         /*
893          * If Aliveness Request and Aliveness Response are set then clear them
894          */
895         if (aliveness_req) {
896                 mei_txe_aliveness_set(dev, 0);
897                 if (mei_txe_aliveness_poll(dev, 0) < 0) {
898                         dev_err(dev->dev, "wait for aliveness failed ... bailing out\n");
899                         return -EIO;
900                 }
901         }
902
903         /*
904          * Set readiness RDY_CLR bit
905          */
906         mei_txe_readiness_clear(dev);
907
908         return 0;
909 }
910
911 /**
912  * mei_txe_hw_start - start the hardware after reset
913  *
914  * @dev: the device structure
915  *
916  * Return: 0 on success an error code otherwise
917  */
918 static int mei_txe_hw_start(struct mei_device *dev)
919 {
920         struct mei_txe_hw *hw = to_txe_hw(dev);
921         int ret;
922
923         u32 hisr;
924
925         /* bring back interrupts */
926         mei_txe_intr_enable(dev);
927
928         ret = mei_txe_readiness_wait(dev);
929         if (ret < 0) {
930                 dev_err(dev->dev, "waiting for readiness failed\n");
931                 return ret;
932         }
933
934         /*
935          * If HISR.INT2_STS interrupt status bit is set then clear it.
936          */
937         hisr = mei_txe_br_reg_read(hw, HISR_REG);
938         if (hisr & HISR_INT_2_STS)
939                 mei_txe_br_reg_write(hw, HISR_REG, HISR_INT_2_STS);
940
941         /* Clear the interrupt cause of OutputDoorbell */
942         clear_bit(TXE_INTR_OUT_DB_BIT, &hw->intr_cause);
943
944         ret = mei_txe_aliveness_set_sync(dev, 1);
945         if (ret < 0) {
946                 dev_err(dev->dev, "wait for aliveness failed ... bailing out\n");
947                 return ret;
948         }
949
950         pm_runtime_set_active(dev->dev);
951
952         /* enable input ready interrupts:
953          * SEC_IPC_HOST_INT_MASK.IPC_INPUT_READY_INT_MASK
954          */
955         mei_txe_input_ready_interrupt_enable(dev);
956
957
958         /*  Set the SICR_SEC_IPC_OUTPUT_STATUS.IPC_OUTPUT_READY bit */
959         mei_txe_output_ready_set(hw);
960
961         /* Set bit SICR_HOST_IPC_READINESS.HOST_RDY
962          */
963         mei_txe_readiness_set_host_rdy(dev);
964
965         return 0;
966 }
967
968 /**
969  * mei_txe_check_and_ack_intrs - translate multi BAR interrupt into
970  *  single bit mask and acknowledge the interrupts
971  *
972  * @dev: the device structure
973  * @do_ack: acknowledge interrupts
974  *
975  * Return: true if found interrupts to process.
976  */
977 static bool mei_txe_check_and_ack_intrs(struct mei_device *dev, bool do_ack)
978 {
979         struct mei_txe_hw *hw = to_txe_hw(dev);
980         u32 hisr;
981         u32 hhisr;
982         u32 ipc_isr;
983         u32 aliveness;
984         bool generated;
985
986         /* read interrupt registers */
987         hhisr = mei_txe_br_reg_read(hw, HHISR_REG);
988         generated = (hhisr & IPC_HHIER_MSK);
989         if (!generated)
990                 goto out;
991
992         hisr = mei_txe_br_reg_read(hw, HISR_REG);
993
994         aliveness = mei_txe_aliveness_get(dev);
995         if (hhisr & IPC_HHIER_SEC && aliveness) {
996                 ipc_isr = mei_txe_sec_reg_read_silent(hw,
997                                 SEC_IPC_HOST_INT_STATUS_REG);
998         } else {
999                 ipc_isr = 0;
1000                 hhisr &= ~IPC_HHIER_SEC;
1001         }
1002
1003         generated = generated ||
1004                 (hisr & HISR_INT_STS_MSK) ||
1005                 (ipc_isr & SEC_IPC_HOST_INT_STATUS_PENDING);
1006
1007         if (generated && do_ack) {
1008                 /* Save the interrupt causes */
1009                 hw->intr_cause |= hisr & HISR_INT_STS_MSK;
1010                 if (ipc_isr & SEC_IPC_HOST_INT_STATUS_IN_RDY)
1011                         hw->intr_cause |= TXE_INTR_IN_READY;
1012
1013
1014                 mei_txe_intr_disable(dev);
1015                 /* Clear the interrupts in hierarchy:
1016                  * IPC and Bridge, than the High Level */
1017                 mei_txe_sec_reg_write_silent(hw,
1018                         SEC_IPC_HOST_INT_STATUS_REG, ipc_isr);
1019                 mei_txe_br_reg_write(hw, HISR_REG, hisr);
1020                 mei_txe_br_reg_write(hw, HHISR_REG, hhisr);
1021         }
1022
1023 out:
1024         return generated;
1025 }
1026
1027 /**
1028  * mei_txe_irq_quick_handler - The ISR of the MEI device
1029  *
1030  * @irq: The irq number
1031  * @dev_id: pointer to the device structure
1032  *
1033  * Return: IRQ_WAKE_THREAD if interrupt is designed for the device
1034  *         IRQ_NONE otherwise
1035  */
1036 irqreturn_t mei_txe_irq_quick_handler(int irq, void *dev_id)
1037 {
1038         struct mei_device *dev = dev_id;
1039
1040         if (mei_txe_check_and_ack_intrs(dev, true))
1041                 return IRQ_WAKE_THREAD;
1042         return IRQ_NONE;
1043 }
1044
1045
1046 /**
1047  * mei_txe_irq_thread_handler - txe interrupt thread
1048  *
1049  * @irq: The irq number
1050  * @dev_id: pointer to the device structure
1051  *
1052  * Return: IRQ_HANDLED
1053  */
1054 irqreturn_t mei_txe_irq_thread_handler(int irq, void *dev_id)
1055 {
1056         struct mei_device *dev = (struct mei_device *) dev_id;
1057         struct mei_txe_hw *hw = to_txe_hw(dev);
1058         struct list_head cmpl_list;
1059         s32 slots;
1060         int rets = 0;
1061
1062         dev_dbg(dev->dev, "irq thread: Interrupt Registers HHISR|HISR|SEC=%02X|%04X|%02X\n",
1063                 mei_txe_br_reg_read(hw, HHISR_REG),
1064                 mei_txe_br_reg_read(hw, HISR_REG),
1065                 mei_txe_sec_reg_read_silent(hw, SEC_IPC_HOST_INT_STATUS_REG));
1066
1067
1068         /* initialize our complete list */
1069         mutex_lock(&dev->device_lock);
1070         INIT_LIST_HEAD(&cmpl_list);
1071
1072         if (pci_dev_msi_enabled(to_pci_dev(dev->dev)))
1073                 mei_txe_check_and_ack_intrs(dev, true);
1074
1075         /* show irq events */
1076         mei_txe_pending_interrupts(dev);
1077
1078         hw->aliveness = mei_txe_aliveness_get(dev);
1079         hw->readiness = mei_txe_readiness_get(dev);
1080
1081         /* Readiness:
1082          * Detection of TXE driver going through reset
1083          * or TXE driver resetting the HECI interface.
1084          */
1085         if (test_and_clear_bit(TXE_INTR_READINESS_BIT, &hw->intr_cause)) {
1086                 dev_dbg(dev->dev, "Readiness Interrupt was received...\n");
1087
1088                 /* Check if SeC is going through reset */
1089                 if (mei_txe_readiness_is_sec_rdy(hw->readiness)) {
1090                         dev_dbg(dev->dev, "we need to start the dev.\n");
1091                         dev->recvd_hw_ready = true;
1092                 } else {
1093                         dev->recvd_hw_ready = false;
1094                         if (dev->dev_state != MEI_DEV_RESETTING) {
1095
1096                                 dev_warn(dev->dev, "FW not ready: resetting.\n");
1097                                 schedule_work(&dev->reset_work);
1098                                 goto end;
1099
1100                         }
1101                 }
1102                 wake_up(&dev->wait_hw_ready);
1103         }
1104
1105         /************************************************************/
1106         /* Check interrupt cause:
1107          * Aliveness: Detection of SeC acknowledge of host request that
1108          * it remain alive or host cancellation of that request.
1109          */
1110
1111         if (test_and_clear_bit(TXE_INTR_ALIVENESS_BIT, &hw->intr_cause)) {
1112                 /* Clear the interrupt cause */
1113                 dev_dbg(dev->dev,
1114                         "Aliveness Interrupt: Status: %d\n", hw->aliveness);
1115                 dev->pg_event = MEI_PG_EVENT_RECEIVED;
1116                 if (waitqueue_active(&hw->wait_aliveness_resp))
1117                         wake_up(&hw->wait_aliveness_resp);
1118         }
1119
1120
1121         /* Output Doorbell:
1122          * Detection of SeC having sent output to host
1123          */
1124         slots = mei_count_full_read_slots(dev);
1125         if (test_and_clear_bit(TXE_INTR_OUT_DB_BIT, &hw->intr_cause)) {
1126                 /* Read from TXE */
1127                 rets = mei_irq_read_handler(dev, &cmpl_list, &slots);
1128                 if (rets &&
1129                     (dev->dev_state != MEI_DEV_RESETTING &&
1130                      dev->dev_state != MEI_DEV_POWER_DOWN)) {
1131                         dev_err(dev->dev,
1132                                 "mei_irq_read_handler ret = %d.\n", rets);
1133
1134                         schedule_work(&dev->reset_work);
1135                         goto end;
1136                 }
1137         }
1138         /* Input Ready: Detection if host can write to SeC */
1139         if (test_and_clear_bit(TXE_INTR_IN_READY_BIT, &hw->intr_cause)) {
1140                 dev->hbuf_is_ready = true;
1141                 hw->slots = TXE_HBUF_DEPTH;
1142         }
1143
1144         if (hw->aliveness && dev->hbuf_is_ready) {
1145                 /* get the real register value */
1146                 dev->hbuf_is_ready = mei_hbuf_is_ready(dev);
1147                 rets = mei_irq_write_handler(dev, &cmpl_list);
1148                 if (rets && rets != -EMSGSIZE)
1149                         dev_err(dev->dev, "mei_irq_write_handler ret = %d.\n",
1150                                 rets);
1151                 dev->hbuf_is_ready = mei_hbuf_is_ready(dev);
1152         }
1153
1154         mei_irq_compl_handler(dev, &cmpl_list);
1155
1156 end:
1157         dev_dbg(dev->dev, "interrupt thread end ret = %d\n", rets);
1158
1159         mutex_unlock(&dev->device_lock);
1160
1161         mei_enable_interrupts(dev);
1162         return IRQ_HANDLED;
1163 }
1164
1165 static const struct mei_hw_ops mei_txe_hw_ops = {
1166
1167         .host_is_ready = mei_txe_host_is_ready,
1168
1169         .fw_status = mei_txe_fw_status,
1170         .pg_state = mei_txe_pg_state,
1171
1172         .hw_is_ready = mei_txe_hw_is_ready,
1173         .hw_reset = mei_txe_hw_reset,
1174         .hw_config = mei_txe_hw_config,
1175         .hw_start = mei_txe_hw_start,
1176
1177         .pg_in_transition = mei_txe_pg_in_transition,
1178         .pg_is_enabled = mei_txe_pg_is_enabled,
1179
1180         .intr_clear = mei_txe_intr_clear,
1181         .intr_enable = mei_txe_intr_enable,
1182         .intr_disable = mei_txe_intr_disable,
1183         .synchronize_irq = mei_txe_synchronize_irq,
1184
1185         .hbuf_free_slots = mei_txe_hbuf_empty_slots,
1186         .hbuf_is_ready = mei_txe_is_input_ready,
1187         .hbuf_depth = mei_txe_hbuf_depth,
1188
1189         .write = mei_txe_write,
1190
1191         .rdbuf_full_slots = mei_txe_count_full_read_slots,
1192         .read_hdr = mei_txe_read_hdr,
1193
1194         .read = mei_txe_read,
1195
1196 };
1197
1198 /**
1199  * mei_txe_dev_init - allocates and initializes txe hardware specific structure
1200  *
1201  * @pdev: pci device
1202  *
1203  * Return: struct mei_device * on success or NULL
1204  */
1205 struct mei_device *mei_txe_dev_init(struct pci_dev *pdev)
1206 {
1207         struct mei_device *dev;
1208         struct mei_txe_hw *hw;
1209
1210         dev = devm_kzalloc(&pdev->dev, sizeof(struct mei_device) +
1211                            sizeof(struct mei_txe_hw), GFP_KERNEL);
1212         if (!dev)
1213                 return NULL;
1214
1215         mei_device_init(dev, &pdev->dev, &mei_txe_hw_ops);
1216
1217         hw = to_txe_hw(dev);
1218
1219         init_waitqueue_head(&hw->wait_aliveness_resp);
1220
1221         return dev;
1222 }
1223
1224 /**
1225  * mei_txe_setup_satt2 - SATT2 configuration for DMA support.
1226  *
1227  * @dev:   the device structure
1228  * @addr:  physical address start of the range
1229  * @range: physical range size
1230  *
1231  * Return: 0 on success an error code otherwise
1232  */
1233 int mei_txe_setup_satt2(struct mei_device *dev, phys_addr_t addr, u32 range)
1234 {
1235         struct mei_txe_hw *hw = to_txe_hw(dev);
1236
1237         u32 lo32 = lower_32_bits(addr);
1238         u32 hi32 = upper_32_bits(addr);
1239         u32 ctrl;
1240
1241         /* SATT is limited to 36 Bits */
1242         if (hi32 & ~0xF)
1243                 return -EINVAL;
1244
1245         /* SATT has to be 16Byte aligned */
1246         if (lo32 & 0xF)
1247                 return -EINVAL;
1248
1249         /* SATT range has to be 4Bytes aligned */
1250         if (range & 0x4)
1251                 return -EINVAL;
1252
1253         /* SATT is limited to 32 MB range*/
1254         if (range > SATT_RANGE_MAX)
1255                 return -EINVAL;
1256
1257         ctrl = SATT2_CTRL_VALID_MSK;
1258         ctrl |= hi32  << SATT2_CTRL_BR_BASE_ADDR_REG_SHIFT;
1259
1260         mei_txe_br_reg_write(hw, SATT2_SAP_SIZE_REG, range);
1261         mei_txe_br_reg_write(hw, SATT2_BRG_BA_LSB_REG, lo32);
1262         mei_txe_br_reg_write(hw, SATT2_CTRL_REG, ctrl);
1263         dev_dbg(dev->dev, "SATT2: SAP_SIZE_OFFSET=0x%08X, BRG_BA_LSB_OFFSET=0x%08X, CTRL_OFFSET=0x%08X\n",
1264                 range, lo32, ctrl);
1265
1266         return 0;
1267 }