19fff0425STomas Winkler // SPDX-License-Identifier: GPL-2.0
2ffc2825cSGreg Kroah-Hartman /*
31e55b609STomas Winkler * Copyright (c) 2003-2018, Intel Corporation. All rights reserved.
4ffc2825cSGreg Kroah-Hartman * Intel Management Engine Interface (Intel MEI) Linux driver
5ffc2825cSGreg Kroah-Hartman */
6ffc2825cSGreg Kroah-Hartman
740e0b67bSTomas Winkler #include <linux/export.h>
8ffc2825cSGreg Kroah-Hartman #include <linux/kthread.h>
9ffc2825cSGreg Kroah-Hartman #include <linux/interrupt.h>
10ffc2825cSGreg Kroah-Hartman #include <linux/fs.h>
11ffc2825cSGreg Kroah-Hartman #include <linux/jiffies.h>
121f180359STomas Winkler #include <linux/slab.h>
1334af1913SAlexander Usyskin #include <linux/pm_runtime.h>
14ffc2825cSGreg Kroah-Hartman
154f3afe1dSTomas Winkler #include <linux/mei.h>
1647a73801STomas Winkler
1747a73801STomas Winkler #include "mei_dev.h"
180edb23fcSTomas Winkler #include "hbm.h"
1990e0b5f1STomas Winkler #include "client.h"
20ffc2825cSGreg Kroah-Hartman
21ffc2825cSGreg Kroah-Hartman
22ffc2825cSGreg Kroah-Hartman /**
2383ce0741SAlexander Usyskin * mei_irq_compl_handler - dispatch complete handlers
244c6e22b8STomas Winkler * for the completed callbacks
254c6e22b8STomas Winkler *
26a8605ea2SAlexander Usyskin * @dev: mei device
27962ff7bcSAlexander Usyskin * @cmpl_list: list of completed cbs
284c6e22b8STomas Winkler */
mei_irq_compl_handler(struct mei_device * dev,struct list_head * cmpl_list)29962ff7bcSAlexander Usyskin void mei_irq_compl_handler(struct mei_device *dev, struct list_head *cmpl_list)
304c6e22b8STomas Winkler {
314c6e22b8STomas Winkler struct mei_cl_cb *cb, *next;
324c6e22b8STomas Winkler struct mei_cl *cl;
334c6e22b8STomas Winkler
34962ff7bcSAlexander Usyskin list_for_each_entry_safe(cb, next, cmpl_list, list) {
354c6e22b8STomas Winkler cl = cb->cl;
36c54bf3abSTomas Winkler list_del_init(&cb->list);
374c6e22b8STomas Winkler
382bf94cabSTomas Winkler dev_dbg(dev->dev, "completing call back.\n");
39db086fa9STomas Winkler mei_cl_complete(cl, cb);
404c6e22b8STomas Winkler }
414c6e22b8STomas Winkler }
4240e0b67bSTomas Winkler EXPORT_SYMBOL_GPL(mei_irq_compl_handler);
436e0f180fSTomas Winkler
444c6e22b8STomas Winkler /**
456e0f180fSTomas Winkler * mei_cl_hbm_equal - check if hbm is addressed to the client
46ffc2825cSGreg Kroah-Hartman *
476e0f180fSTomas Winkler * @cl: host client
48ffc2825cSGreg Kroah-Hartman * @mei_hdr: header of mei client message
49ffc2825cSGreg Kroah-Hartman *
50a8605ea2SAlexander Usyskin * Return: true if matches, false otherwise
51ffc2825cSGreg Kroah-Hartman */
mei_cl_hbm_equal(struct mei_cl * cl,struct mei_msg_hdr * mei_hdr)526e0f180fSTomas Winkler static inline int mei_cl_hbm_equal(struct mei_cl *cl,
53ffc2825cSGreg Kroah-Hartman struct mei_msg_hdr *mei_hdr)
54ffc2825cSGreg Kroah-Hartman {
551df629efSAlexander Usyskin return mei_cl_host_addr(cl) == mei_hdr->host_addr &&
56d49ed64aSAlexander Usyskin mei_cl_me_id(cl) == mei_hdr->me_addr;
576e0f180fSTomas Winkler }
58ffc2825cSGreg Kroah-Hartman
59ffc2825cSGreg Kroah-Hartman /**
60331e4187STomas Winkler * mei_irq_discard_msg - discard received message
61331e4187STomas Winkler *
62331e4187STomas Winkler * @dev: mei device
63331e4187STomas Winkler * @hdr: message header
640cd7c01aSTomas Winkler * @discard_len: the length of the message to discard (excluding header)
65331e4187STomas Winkler */
mei_irq_discard_msg(struct mei_device * dev,struct mei_msg_hdr * hdr,size_t discard_len)660cd7c01aSTomas Winkler static void mei_irq_discard_msg(struct mei_device *dev, struct mei_msg_hdr *hdr,
670cd7c01aSTomas Winkler size_t discard_len)
68331e4187STomas Winkler {
690cd7c01aSTomas Winkler if (hdr->dma_ring) {
700cd7c01aSTomas Winkler mei_dma_ring_read(dev, NULL,
710cd7c01aSTomas Winkler hdr->extension[dev->rd_msg_hdr_count - 2]);
720cd7c01aSTomas Winkler discard_len = 0;
730cd7c01aSTomas Winkler }
74331e4187STomas Winkler /*
75331e4187STomas Winkler * no need to check for size as it is guarantied
76331e4187STomas Winkler * that length fits into rd_msg_buf
77331e4187STomas Winkler */
780cd7c01aSTomas Winkler mei_read_slots(dev, dev->rd_msg_buf, discard_len);
79331e4187STomas Winkler dev_dbg(dev->dev, "discarding message " MEI_HDR_FMT "\n",
80331e4187STomas Winkler MEI_HDR_PRM(hdr));
81331e4187STomas Winkler }
82331e4187STomas Winkler
83331e4187STomas Winkler /**
84ce23139cSAlexander Usyskin * mei_cl_irq_read_msg - process client message
85ffc2825cSGreg Kroah-Hartman *
863d33ff24STomas Winkler * @cl: reading client
87ffc2825cSGreg Kroah-Hartman * @mei_hdr: header of mei client message
880cd7c01aSTomas Winkler * @meta: extend meta header
89962ff7bcSAlexander Usyskin * @cmpl_list: completion list
90ffc2825cSGreg Kroah-Hartman *
913d33ff24STomas Winkler * Return: always 0
92ffc2825cSGreg Kroah-Hartman */
mei_cl_irq_read_msg(struct mei_cl * cl,struct mei_msg_hdr * mei_hdr,struct mei_ext_meta_hdr * meta,struct list_head * cmpl_list)93394a77d0SAlexander Usyskin static int mei_cl_irq_read_msg(struct mei_cl *cl,
946e0f180fSTomas Winkler struct mei_msg_hdr *mei_hdr,
950cd7c01aSTomas Winkler struct mei_ext_meta_hdr *meta,
96962ff7bcSAlexander Usyskin struct list_head *cmpl_list)
97ffc2825cSGreg Kroah-Hartman {
983d33ff24STomas Winkler struct mei_device *dev = cl->dev;
993d33ff24STomas Winkler struct mei_cl_cb *cb;
1000cd7c01aSTomas Winkler
101*4ed1cc99STomas Winkler struct mei_ext_hdr_vtag *vtag_hdr = NULL;
102*4ed1cc99STomas Winkler struct mei_ext_hdr_gsc_f2h *gsc_f2h = NULL;
103*4ed1cc99STomas Winkler
104f862b6b2STomas Winkler size_t buf_sz;
1056316321fSTomas Winkler u32 length;
106*4ed1cc99STomas Winkler u32 ext_len;
1070cd7c01aSTomas Winkler
1080cd7c01aSTomas Winkler length = mei_hdr->length;
1090cd7c01aSTomas Winkler ext_len = 0;
1100cd7c01aSTomas Winkler if (mei_hdr->extended) {
1110cd7c01aSTomas Winkler ext_len = sizeof(*meta) + mei_slots2data(meta->size);
1120cd7c01aSTomas Winkler length -= ext_len;
1130cd7c01aSTomas Winkler }
114ffc2825cSGreg Kroah-Hartman
115a9bed610STomas Winkler cb = list_first_entry_or_null(&cl->rd_pending, struct mei_cl_cb, list);
116a9bed610STomas Winkler if (!cb) {
117a808c80cSAlexander Usyskin if (!mei_cl_is_fixed_address(cl)) {
118a9bed610STomas Winkler cl_err(dev, cl, "pending read cb not found\n");
119dfe5f753SAlexander Usyskin goto discard;
1203d33ff24STomas Winkler }
121a808c80cSAlexander Usyskin cb = mei_cl_alloc_cb(cl, mei_cl_mtu(cl), MEI_FOP_READ, cl->fp);
122a808c80cSAlexander Usyskin if (!cb)
123dfe5f753SAlexander Usyskin goto discard;
124a808c80cSAlexander Usyskin list_add_tail(&cb->list, &cl->rd_pending);
125a808c80cSAlexander Usyskin }
1263d33ff24STomas Winkler
1270cd7c01aSTomas Winkler if (mei_hdr->extended) {
128*4ed1cc99STomas Winkler struct mei_ext_hdr *ext = mei_ext_begin(meta);
1290cd7c01aSTomas Winkler do {
1300cd7c01aSTomas Winkler switch (ext->type) {
1310cd7c01aSTomas Winkler case MEI_EXT_HDR_VTAG:
13240292383STomas Winkler vtag_hdr = (struct mei_ext_hdr_vtag *)ext;
1330cd7c01aSTomas Winkler break;
134*4ed1cc99STomas Winkler case MEI_EXT_HDR_GSC:
135*4ed1cc99STomas Winkler gsc_f2h = (struct mei_ext_hdr_gsc_f2h *)ext;
136*4ed1cc99STomas Winkler cb->ext_hdr = kzalloc(sizeof(*gsc_f2h), GFP_KERNEL);
137*4ed1cc99STomas Winkler if (!cb->ext_hdr) {
138*4ed1cc99STomas Winkler cb->status = -ENOMEM;
139*4ed1cc99STomas Winkler goto discard;
140*4ed1cc99STomas Winkler }
141*4ed1cc99STomas Winkler break;
1420cd7c01aSTomas Winkler case MEI_EXT_HDR_NONE:
1430cd7c01aSTomas Winkler fallthrough;
1440cd7c01aSTomas Winkler default:
145*4ed1cc99STomas Winkler cl_err(dev, cl, "unknown extended header\n");
1460cd7c01aSTomas Winkler cb->status = -EPROTO;
1470cd7c01aSTomas Winkler break;
1480cd7c01aSTomas Winkler }
1490cd7c01aSTomas Winkler
1500cd7c01aSTomas Winkler ext = mei_ext_next(ext);
1510cd7c01aSTomas Winkler } while (!mei_ext_last(meta, ext));
1520cd7c01aSTomas Winkler
153*4ed1cc99STomas Winkler if (!vtag_hdr && !gsc_f2h) {
154*4ed1cc99STomas Winkler cl_dbg(dev, cl, "no vtag or gsc found in extended header.\n");
1550cd7c01aSTomas Winkler cb->status = -EPROTO;
1560cd7c01aSTomas Winkler goto discard;
1570cd7c01aSTomas Winkler }
158*4ed1cc99STomas Winkler }
1590cd7c01aSTomas Winkler
160*4ed1cc99STomas Winkler if (vtag_hdr) {
16140292383STomas Winkler cl_dbg(dev, cl, "vtag: %d\n", vtag_hdr->vtag);
16240292383STomas Winkler if (cb->vtag && cb->vtag != vtag_hdr->vtag) {
1630cd7c01aSTomas Winkler cl_err(dev, cl, "mismatched tag: %d != %d\n",
16440292383STomas Winkler cb->vtag, vtag_hdr->vtag);
1650cd7c01aSTomas Winkler cb->status = -EPROTO;
1660cd7c01aSTomas Winkler goto discard;
1670cd7c01aSTomas Winkler }
16840292383STomas Winkler cb->vtag = vtag_hdr->vtag;
1690cd7c01aSTomas Winkler }
1700cd7c01aSTomas Winkler
171*4ed1cc99STomas Winkler if (gsc_f2h) {
172*4ed1cc99STomas Winkler u32 ext_hdr_len = mei_ext_hdr_len(&gsc_f2h->hdr);
173*4ed1cc99STomas Winkler
174*4ed1cc99STomas Winkler if (!dev->hbm_f_gsc_supported) {
175*4ed1cc99STomas Winkler cl_err(dev, cl, "gsc extended header is not supported\n");
176*4ed1cc99STomas Winkler cb->status = -EPROTO;
177*4ed1cc99STomas Winkler goto discard;
178*4ed1cc99STomas Winkler }
179*4ed1cc99STomas Winkler
180*4ed1cc99STomas Winkler if (length) {
181*4ed1cc99STomas Winkler cl_err(dev, cl, "no data allowed in cb with gsc\n");
182*4ed1cc99STomas Winkler cb->status = -EPROTO;
183*4ed1cc99STomas Winkler goto discard;
184*4ed1cc99STomas Winkler }
185*4ed1cc99STomas Winkler if (ext_hdr_len > sizeof(*gsc_f2h)) {
186*4ed1cc99STomas Winkler cl_err(dev, cl, "gsc extended header is too big %u\n", ext_hdr_len);
187*4ed1cc99STomas Winkler cb->status = -EPROTO;
188*4ed1cc99STomas Winkler goto discard;
189*4ed1cc99STomas Winkler }
190*4ed1cc99STomas Winkler memcpy(cb->ext_hdr, gsc_f2h, ext_hdr_len);
191*4ed1cc99STomas Winkler }
192*4ed1cc99STomas Winkler
193f3de9b63STomas Winkler if (!mei_cl_is_connected(cl)) {
194a9bed610STomas Winkler cl_dbg(dev, cl, "not connected\n");
195a9bed610STomas Winkler cb->status = -ENODEV;
196dfe5f753SAlexander Usyskin goto discard;
197ffc2825cSGreg Kroah-Hartman }
198ffc2825cSGreg Kroah-Hartman
1990cd7c01aSTomas Winkler if (mei_hdr->dma_ring)
2000cd7c01aSTomas Winkler length = mei_hdr->extension[mei_data2slots(ext_len)];
2016316321fSTomas Winkler
2026316321fSTomas Winkler buf_sz = length + cb->buf_idx;
203f862b6b2STomas Winkler /* catch for integer overflow */
204f862b6b2STomas Winkler if (buf_sz < cb->buf_idx) {
20535bf7692SAlexander Usyskin cl_err(dev, cl, "message is too big len %d idx %zu\n",
2066316321fSTomas Winkler length, cb->buf_idx);
207f862b6b2STomas Winkler cb->status = -EMSGSIZE;
208dfe5f753SAlexander Usyskin goto discard;
209f862b6b2STomas Winkler }
210f862b6b2STomas Winkler
211f862b6b2STomas Winkler if (cb->buf.size < buf_sz) {
21235bf7692SAlexander Usyskin cl_dbg(dev, cl, "message overflow. size %zu len %d idx %zu\n",
2136316321fSTomas Winkler cb->buf.size, length, cb->buf_idx);
214dfe5f753SAlexander Usyskin cb->status = -EMSGSIZE;
215dfe5f753SAlexander Usyskin goto discard;
216fcb136e1STomas Winkler }
217ffc2825cSGreg Kroah-Hartman
2180cd7c01aSTomas Winkler if (mei_hdr->dma_ring) {
2196316321fSTomas Winkler mei_dma_ring_read(dev, cb->buf.data + cb->buf_idx, length);
2200cd7c01aSTomas Winkler /* for DMA read 0 length to generate interrupt to the device */
2210cd7c01aSTomas Winkler mei_read_slots(dev, cb->buf.data + cb->buf_idx, 0);
2220cd7c01aSTomas Winkler } else {
2230cd7c01aSTomas Winkler mei_read_slots(dev, cb->buf.data + cb->buf_idx, length);
2240cd7c01aSTomas Winkler }
2256e0f180fSTomas Winkler
2266316321fSTomas Winkler cb->buf_idx += length;
227331e4187STomas Winkler
2286e0f180fSTomas Winkler if (mei_hdr->msg_complete) {
22935bf7692SAlexander Usyskin cl_dbg(dev, cl, "completed read length = %zu\n", cb->buf_idx);
230962ff7bcSAlexander Usyskin list_move_tail(&cb->list, cmpl_list);
23134af1913SAlexander Usyskin } else {
23234af1913SAlexander Usyskin pm_runtime_mark_last_busy(dev->dev);
23334af1913SAlexander Usyskin pm_request_autosuspend(dev->dev);
234ffc2825cSGreg Kroah-Hartman }
235ffc2825cSGreg Kroah-Hartman
236dfe5f753SAlexander Usyskin return 0;
237ffc2825cSGreg Kroah-Hartman
238dfe5f753SAlexander Usyskin discard:
23917ba8a08STomas Winkler if (cb)
240962ff7bcSAlexander Usyskin list_move_tail(&cb->list, cmpl_list);
2410cd7c01aSTomas Winkler mei_irq_discard_msg(dev, mei_hdr, length);
242ffc2825cSGreg Kroah-Hartman return 0;
243ffc2825cSGreg Kroah-Hartman }
244ffc2825cSGreg Kroah-Hartman
245ffc2825cSGreg Kroah-Hartman /**
2466bb948c9STomas Winkler * mei_cl_irq_disconnect_rsp - send disconnection response message
2476bb948c9STomas Winkler *
2486bb948c9STomas Winkler * @cl: client
2496bb948c9STomas Winkler * @cb: callback block.
2506bb948c9STomas Winkler * @cmpl_list: complete list.
2516bb948c9STomas Winkler *
252a8605ea2SAlexander Usyskin * Return: 0, OK; otherwise, error.
2536bb948c9STomas Winkler */
mei_cl_irq_disconnect_rsp(struct mei_cl * cl,struct mei_cl_cb * cb,struct list_head * cmpl_list)2546bb948c9STomas Winkler static int mei_cl_irq_disconnect_rsp(struct mei_cl *cl, struct mei_cl_cb *cb,
255962ff7bcSAlexander Usyskin struct list_head *cmpl_list)
2566bb948c9STomas Winkler {
2576bb948c9STomas Winkler struct mei_device *dev = cl->dev;
2589d098192STomas Winkler u32 msg_slots;
2599d098192STomas Winkler int slots;
2606bb948c9STomas Winkler int ret;
2616bb948c9STomas Winkler
26298e70866STomas Winkler msg_slots = mei_hbm2slots(sizeof(struct hbm_client_connect_response));
263de877437STomas Winkler slots = mei_hbuf_empty_slots(dev);
264de877437STomas Winkler if (slots < 0)
265de877437STomas Winkler return -EOVERFLOW;
2666bb948c9STomas Winkler
267de877437STomas Winkler if ((u32)slots < msg_slots)
2686bb948c9STomas Winkler return -EMSGSIZE;
2696bb948c9STomas Winkler
2706bb948c9STomas Winkler ret = mei_hbm_cl_disconnect_rsp(dev, cl);
271962ff7bcSAlexander Usyskin list_move_tail(&cb->list, cmpl_list);
2726bb948c9STomas Winkler
2736bb948c9STomas Winkler return ret;
2746bb948c9STomas Winkler }
2756bb948c9STomas Winkler
276ffc2825cSGreg Kroah-Hartman /**
277ce23139cSAlexander Usyskin * mei_cl_irq_read - processes client read related operation from the
2786220d6a0STomas Winkler * interrupt thread context - request for flow control credits
279ffc2825cSGreg Kroah-Hartman *
2806220d6a0STomas Winkler * @cl: client
2816220d6a0STomas Winkler * @cb: callback block.
282ffc2825cSGreg Kroah-Hartman * @cmpl_list: complete list.
283ffc2825cSGreg Kroah-Hartman *
284a8605ea2SAlexander Usyskin * Return: 0, OK; otherwise, error.
285ffc2825cSGreg Kroah-Hartman */
mei_cl_irq_read(struct mei_cl * cl,struct mei_cl_cb * cb,struct list_head * cmpl_list)2866220d6a0STomas Winkler static int mei_cl_irq_read(struct mei_cl *cl, struct mei_cl_cb *cb,
287962ff7bcSAlexander Usyskin struct list_head *cmpl_list)
288ffc2825cSGreg Kroah-Hartman {
2896220d6a0STomas Winkler struct mei_device *dev = cl->dev;
2909d098192STomas Winkler u32 msg_slots;
2919d098192STomas Winkler int slots;
2922ebf8c94STomas Winkler int ret;
2932ebf8c94STomas Winkler
294ff1586a7SAlexander Usyskin if (!list_empty(&cl->rd_pending))
295ff1586a7SAlexander Usyskin return 0;
296ff1586a7SAlexander Usyskin
29798e70866STomas Winkler msg_slots = mei_hbm2slots(sizeof(struct hbm_flow_control));
2989d098192STomas Winkler slots = mei_hbuf_empty_slots(dev);
299de877437STomas Winkler if (slots < 0)
300de877437STomas Winkler return -EOVERFLOW;
3012ebf8c94STomas Winkler
302de877437STomas Winkler if ((u32)slots < msg_slots)
303c8c8d080STomas Winkler return -EMSGSIZE;
3047bdf72d3STomas Winkler
3052ebf8c94STomas Winkler ret = mei_hbm_cl_flow_control_req(dev, cl);
3062ebf8c94STomas Winkler if (ret) {
3072ebf8c94STomas Winkler cl->status = ret;
3086220d6a0STomas Winkler cb->buf_idx = 0;
309962ff7bcSAlexander Usyskin list_move_tail(&cb->list, cmpl_list);
3102ebf8c94STomas Winkler return ret;
311ffc2825cSGreg Kroah-Hartman }
3122ebf8c94STomas Winkler
313bbf0a947SAlexander Usyskin pm_runtime_mark_last_busy(dev->dev);
314bbf0a947SAlexander Usyskin pm_request_autosuspend(dev->dev);
315bbf0a947SAlexander Usyskin
316a9bed610STomas Winkler list_move_tail(&cb->list, &cl->rd_pending);
317ffc2825cSGreg Kroah-Hartman
318ffc2825cSGreg Kroah-Hartman return 0;
319ffc2825cSGreg Kroah-Hartman }
320ffc2825cSGreg Kroah-Hartman
hdr_is_hbm(struct mei_msg_hdr * mei_hdr)321603c53e4SAlexander Usyskin static inline bool hdr_is_hbm(struct mei_msg_hdr *mei_hdr)
322603c53e4SAlexander Usyskin {
323603c53e4SAlexander Usyskin return mei_hdr->host_addr == 0 && mei_hdr->me_addr == 0;
324603c53e4SAlexander Usyskin }
325603c53e4SAlexander Usyskin
hdr_is_fixed(struct mei_msg_hdr * mei_hdr)326603c53e4SAlexander Usyskin static inline bool hdr_is_fixed(struct mei_msg_hdr *mei_hdr)
327603c53e4SAlexander Usyskin {
328603c53e4SAlexander Usyskin return mei_hdr->host_addr == 0 && mei_hdr->me_addr != 0;
329603c53e4SAlexander Usyskin }
330603c53e4SAlexander Usyskin
hdr_is_valid(u32 msg_hdr)33199c06866STomas Winkler static inline int hdr_is_valid(u32 msg_hdr)
33299c06866STomas Winkler {
33399c06866STomas Winkler struct mei_msg_hdr *mei_hdr;
3341309ecc9SAlexander Usyskin u32 expected_len = 0;
33599c06866STomas Winkler
33699c06866STomas Winkler mei_hdr = (struct mei_msg_hdr *)&msg_hdr;
33799c06866STomas Winkler if (!msg_hdr || mei_hdr->reserved)
33899c06866STomas Winkler return -EBADMSG;
33999c06866STomas Winkler
3401309ecc9SAlexander Usyskin if (mei_hdr->dma_ring)
3411309ecc9SAlexander Usyskin expected_len += MEI_SLOT_SIZE;
3421309ecc9SAlexander Usyskin if (mei_hdr->extended)
3431309ecc9SAlexander Usyskin expected_len += MEI_SLOT_SIZE;
3441309ecc9SAlexander Usyskin if (mei_hdr->length < expected_len)
3456316321fSTomas Winkler return -EBADMSG;
3466316321fSTomas Winkler
34799c06866STomas Winkler return 0;
34899c06866STomas Winkler }
34999c06866STomas Winkler
350ffc2825cSGreg Kroah-Hartman /**
351393b148fSMasanari Iida * mei_irq_read_handler - bottom half read routine after ISR to
352ffc2825cSGreg Kroah-Hartman * handle the read processing.
353ffc2825cSGreg Kroah-Hartman *
354ffc2825cSGreg Kroah-Hartman * @dev: the device structure
35506ecd645STomas Winkler * @cmpl_list: An instance of our list structure
356ffc2825cSGreg Kroah-Hartman * @slots: slots to read.
357ffc2825cSGreg Kroah-Hartman *
358a8605ea2SAlexander Usyskin * Return: 0 on success, <0 on failure.
359ffc2825cSGreg Kroah-Hartman */
mei_irq_read_handler(struct mei_device * dev,struct list_head * cmpl_list,s32 * slots)36006ecd645STomas Winkler int mei_irq_read_handler(struct mei_device *dev,
361962ff7bcSAlexander Usyskin struct list_head *cmpl_list, s32 *slots)
362ffc2825cSGreg Kroah-Hartman {
363ffc2825cSGreg Kroah-Hartman struct mei_msg_hdr *mei_hdr;
3640cd7c01aSTomas Winkler struct mei_ext_meta_hdr *meta_hdr = NULL;
36510ee9074STomas Winkler struct mei_cl *cl;
36610ee9074STomas Winkler int ret;
3671309ecc9SAlexander Usyskin u32 hdr_size_left;
3681309ecc9SAlexander Usyskin u32 hdr_size_ext;
3690cd7c01aSTomas Winkler int i;
3700cd7c01aSTomas Winkler int ext_hdr_end;
371ffc2825cSGreg Kroah-Hartman
3726316321fSTomas Winkler if (!dev->rd_msg_hdr[0]) {
3736316321fSTomas Winkler dev->rd_msg_hdr[0] = mei_read_hdr(dev);
3740cd7c01aSTomas Winkler dev->rd_msg_hdr_count = 1;
375ffc2825cSGreg Kroah-Hartman (*slots)--;
3762bf94cabSTomas Winkler dev_dbg(dev->dev, "slots =%08x.\n", *slots);
377ffc2825cSGreg Kroah-Hartman
3786316321fSTomas Winkler ret = hdr_is_valid(dev->rd_msg_hdr[0]);
37999c06866STomas Winkler if (ret) {
3802bf94cabSTomas Winkler dev_err(dev->dev, "corrupted message header 0x%08X\n",
3816316321fSTomas Winkler dev->rd_msg_hdr[0]);
382ffc2825cSGreg Kroah-Hartman goto end;
383ffc2825cSGreg Kroah-Hartman }
38499c06866STomas Winkler }
38599c06866STomas Winkler
3866316321fSTomas Winkler mei_hdr = (struct mei_msg_hdr *)dev->rd_msg_hdr;
38799c06866STomas Winkler dev_dbg(dev->dev, MEI_HDR_FMT, MEI_HDR_PRM(mei_hdr));
388ffc2825cSGreg Kroah-Hartman
38910ee9074STomas Winkler if (mei_slots2data(*slots) < mei_hdr->length) {
3902bf94cabSTomas Winkler dev_err(dev->dev, "less data available than length=%08x.\n",
391ffc2825cSGreg Kroah-Hartman *slots);
392ffc2825cSGreg Kroah-Hartman /* we can't read the message */
393b1b94b5dSTomas Winkler ret = -ENODATA;
394ffc2825cSGreg Kroah-Hartman goto end;
395ffc2825cSGreg Kroah-Hartman }
396ffc2825cSGreg Kroah-Hartman
3970cd7c01aSTomas Winkler ext_hdr_end = 1;
3981309ecc9SAlexander Usyskin hdr_size_left = mei_hdr->length;
3990cd7c01aSTomas Winkler
4000cd7c01aSTomas Winkler if (mei_hdr->extended) {
4010cd7c01aSTomas Winkler if (!dev->rd_msg_hdr[1]) {
40240292383STomas Winkler dev->rd_msg_hdr[1] = mei_read_hdr(dev);
4030cd7c01aSTomas Winkler dev->rd_msg_hdr_count++;
4046316321fSTomas Winkler (*slots)--;
40540292383STomas Winkler dev_dbg(dev->dev, "extended header is %08x\n", dev->rd_msg_hdr[1]);
4060cd7c01aSTomas Winkler }
40740292383STomas Winkler meta_hdr = ((struct mei_ext_meta_hdr *)&dev->rd_msg_hdr[1]);
4081309ecc9SAlexander Usyskin if (check_add_overflow((u32)sizeof(*meta_hdr),
4091309ecc9SAlexander Usyskin mei_slots2data(meta_hdr->size),
4101309ecc9SAlexander Usyskin &hdr_size_ext)) {
4111309ecc9SAlexander Usyskin dev_err(dev->dev, "extended message size too big %d\n",
4121309ecc9SAlexander Usyskin meta_hdr->size);
4131309ecc9SAlexander Usyskin return -EBADMSG;
4141309ecc9SAlexander Usyskin }
4151309ecc9SAlexander Usyskin if (hdr_size_left < hdr_size_ext) {
4161309ecc9SAlexander Usyskin dev_err(dev->dev, "corrupted message header len %d\n",
4171309ecc9SAlexander Usyskin mei_hdr->length);
4181309ecc9SAlexander Usyskin return -EBADMSG;
4191309ecc9SAlexander Usyskin }
4201309ecc9SAlexander Usyskin hdr_size_left -= hdr_size_ext;
4211309ecc9SAlexander Usyskin
4220cd7c01aSTomas Winkler ext_hdr_end = meta_hdr->size + 2;
4230cd7c01aSTomas Winkler for (i = dev->rd_msg_hdr_count; i < ext_hdr_end; i++) {
4240cd7c01aSTomas Winkler dev->rd_msg_hdr[i] = mei_read_hdr(dev);
4250cd7c01aSTomas Winkler dev_dbg(dev->dev, "extended header %d is %08x\n", i,
4260cd7c01aSTomas Winkler dev->rd_msg_hdr[i]);
4270cd7c01aSTomas Winkler dev->rd_msg_hdr_count++;
4280cd7c01aSTomas Winkler (*slots)--;
4290cd7c01aSTomas Winkler }
4300cd7c01aSTomas Winkler }
4310cd7c01aSTomas Winkler
4320cd7c01aSTomas Winkler if (mei_hdr->dma_ring) {
4331309ecc9SAlexander Usyskin if (hdr_size_left != sizeof(dev->rd_msg_hdr[ext_hdr_end])) {
4341309ecc9SAlexander Usyskin dev_err(dev->dev, "corrupted message header len %d\n",
4351309ecc9SAlexander Usyskin mei_hdr->length);
4361309ecc9SAlexander Usyskin return -EBADMSG;
4371309ecc9SAlexander Usyskin }
4381309ecc9SAlexander Usyskin
4390cd7c01aSTomas Winkler dev->rd_msg_hdr[ext_hdr_end] = mei_read_hdr(dev);
4400cd7c01aSTomas Winkler dev->rd_msg_hdr_count++;
4410cd7c01aSTomas Winkler (*slots)--;
4420cd7c01aSTomas Winkler mei_hdr->length -= sizeof(dev->rd_msg_hdr[ext_hdr_end]);
4436316321fSTomas Winkler }
4446316321fSTomas Winkler
44510ee9074STomas Winkler /* HBM message */
446603c53e4SAlexander Usyskin if (hdr_is_hbm(mei_hdr)) {
447544f9460STomas Winkler ret = mei_hbm_dispatch(dev, mei_hdr);
448544f9460STomas Winkler if (ret) {
4492bf94cabSTomas Winkler dev_dbg(dev->dev, "mei_hbm_dispatch failed ret = %d\n",
450544f9460STomas Winkler ret);
451544f9460STomas Winkler goto end;
452544f9460STomas Winkler }
45310ee9074STomas Winkler goto reset_slots;
45410ee9074STomas Winkler }
45515d4acc5STomas Winkler
45683ce0741SAlexander Usyskin /* find recipient cl */
45710ee9074STomas Winkler list_for_each_entry(cl, &dev->file_list, link) {
45810ee9074STomas Winkler if (mei_cl_hbm_equal(cl, mei_hdr)) {
45910ee9074STomas Winkler cl_dbg(dev, cl, "got a message\n");
460c10187b1SAlexander Usyskin ret = mei_cl_irq_read_msg(cl, mei_hdr, meta_hdr, cmpl_list);
461c10187b1SAlexander Usyskin goto reset_slots;
46210ee9074STomas Winkler }
46310ee9074STomas Winkler }
46419838fb8STomas Winkler
46583ce0741SAlexander Usyskin /* if no recipient cl was found we assume corrupted header */
466603c53e4SAlexander Usyskin /* A message for not connected fixed address clients
467603c53e4SAlexander Usyskin * should be silently discarded
468b7a020bfSAlexander Usyskin * On power down client may be force cleaned,
469b7a020bfSAlexander Usyskin * silently discard such messages
470603c53e4SAlexander Usyskin */
471b7a020bfSAlexander Usyskin if (hdr_is_fixed(mei_hdr) ||
472b7a020bfSAlexander Usyskin dev->dev_state == MEI_DEV_POWER_DOWN) {
4730cd7c01aSTomas Winkler mei_irq_discard_msg(dev, mei_hdr, mei_hdr->length);
474603c53e4SAlexander Usyskin ret = 0;
475603c53e4SAlexander Usyskin goto reset_slots;
476603c53e4SAlexander Usyskin }
477c10187b1SAlexander Usyskin dev_err(dev->dev, "no destination client found 0x%08X\n", dev->rd_msg_hdr[0]);
47810ee9074STomas Winkler ret = -EBADMSG;
479ffc2825cSGreg Kroah-Hartman goto end;
48010ee9074STomas Winkler
48110ee9074STomas Winkler reset_slots:
482ffc2825cSGreg Kroah-Hartman /* reset the number of slots and header */
4836316321fSTomas Winkler memset(dev->rd_msg_hdr, 0, sizeof(dev->rd_msg_hdr));
4840cd7c01aSTomas Winkler dev->rd_msg_hdr_count = 0;
485ffc2825cSGreg Kroah-Hartman *slots = mei_count_full_read_slots(dev);
486ffc2825cSGreg Kroah-Hartman if (*slots == -EOVERFLOW) {
487ffc2825cSGreg Kroah-Hartman /* overflow - reset */
4882bf94cabSTomas Winkler dev_err(dev->dev, "resetting due to slots overflow.\n");
489ffc2825cSGreg Kroah-Hartman /* set the event since message has been read */
490ffc2825cSGreg Kroah-Hartman ret = -ERANGE;
491ffc2825cSGreg Kroah-Hartman goto end;
492ffc2825cSGreg Kroah-Hartman }
493ffc2825cSGreg Kroah-Hartman end:
494ffc2825cSGreg Kroah-Hartman return ret;
495ffc2825cSGreg Kroah-Hartman }
49640e0b67bSTomas Winkler EXPORT_SYMBOL_GPL(mei_irq_read_handler);
497ffc2825cSGreg Kroah-Hartman
498ffc2825cSGreg Kroah-Hartman
499ffc2825cSGreg Kroah-Hartman /**
50006ecd645STomas Winkler * mei_irq_write_handler - dispatch write requests
50106ecd645STomas Winkler * after irq received
502ffc2825cSGreg Kroah-Hartman *
503ffc2825cSGreg Kroah-Hartman * @dev: the device structure
5049a84d616STomas Winkler * @cmpl_list: An instance of our list structure
505ffc2825cSGreg Kroah-Hartman *
506a8605ea2SAlexander Usyskin * Return: 0 on success, <0 on failure.
507ffc2825cSGreg Kroah-Hartman */
mei_irq_write_handler(struct mei_device * dev,struct list_head * cmpl_list)508962ff7bcSAlexander Usyskin int mei_irq_write_handler(struct mei_device *dev, struct list_head *cmpl_list)
509ffc2825cSGreg Kroah-Hartman {
510ffc2825cSGreg Kroah-Hartman
511ffc2825cSGreg Kroah-Hartman struct mei_cl *cl;
5126220d6a0STomas Winkler struct mei_cl_cb *cb, *next;
5139a84d616STomas Winkler s32 slots;
514ffc2825cSGreg Kroah-Hartman int ret;
515ffc2825cSGreg Kroah-Hartman
5166aae48ffSTomas Winkler
5176aae48ffSTomas Winkler if (!mei_hbuf_acquire(dev))
518ffc2825cSGreg Kroah-Hartman return 0;
5196aae48ffSTomas Winkler
5209a84d616STomas Winkler slots = mei_hbuf_empty_slots(dev);
521de877437STomas Winkler if (slots < 0)
522de877437STomas Winkler return -EOVERFLOW;
523de877437STomas Winkler
524de877437STomas Winkler if (slots == 0)
5257d5e0e59STomas Winkler return -EMSGSIZE;
5267d5e0e59STomas Winkler
527ffc2825cSGreg Kroah-Hartman /* complete all waiting for write CB */
5282bf94cabSTomas Winkler dev_dbg(dev->dev, "complete all waiting for write cb.\n");
529ffc2825cSGreg Kroah-Hartman
530962ff7bcSAlexander Usyskin list_for_each_entry_safe(cb, next, &dev->write_waiting_list, list) {
5316220d6a0STomas Winkler cl = cb->cl;
532ffc2825cSGreg Kroah-Hartman
533ffc2825cSGreg Kroah-Hartman cl->status = 0;
534c0abffbdSAlexander Usyskin cl_dbg(dev, cl, "MEI WRITE COMPLETE\n");
535ffc2825cSGreg Kroah-Hartman cl->writing_state = MEI_WRITE_COMPLETE;
536962ff7bcSAlexander Usyskin list_move_tail(&cb->list, cmpl_list);
537ffc2825cSGreg Kroah-Hartman }
538ffc2825cSGreg Kroah-Hartman
539ffc2825cSGreg Kroah-Hartman /* complete control write list CB */
5402bf94cabSTomas Winkler dev_dbg(dev->dev, "complete control write list cb.\n");
541962ff7bcSAlexander Usyskin list_for_each_entry_safe(cb, next, &dev->ctrl_wr_list, list) {
5426220d6a0STomas Winkler cl = cb->cl;
5436220d6a0STomas Winkler switch (cb->fop_type) {
5445a8373fbSTomas Winkler case MEI_FOP_DISCONNECT:
545ffc2825cSGreg Kroah-Hartman /* send disconnect message */
5465a8373fbSTomas Winkler ret = mei_cl_irq_disconnect(cl, cb, cmpl_list);
547ffc2825cSGreg Kroah-Hartman if (ret)
548ffc2825cSGreg Kroah-Hartman return ret;
549ffc2825cSGreg Kroah-Hartman
550ffc2825cSGreg Kroah-Hartman break;
5514b8960b4STomas Winkler case MEI_FOP_READ:
552ffc2825cSGreg Kroah-Hartman /* send flow control message */
5539d098192STomas Winkler ret = mei_cl_irq_read(cl, cb, cmpl_list);
554ffc2825cSGreg Kroah-Hartman if (ret)
555ffc2825cSGreg Kroah-Hartman return ret;
556ffc2825cSGreg Kroah-Hartman
557ffc2825cSGreg Kroah-Hartman break;
55802a7eeccSTomas Winkler case MEI_FOP_CONNECT:
559ffc2825cSGreg Kroah-Hartman /* connect message */
5609d098192STomas Winkler ret = mei_cl_irq_connect(cl, cb, cmpl_list);
561ffc2825cSGreg Kroah-Hartman if (ret)
562ffc2825cSGreg Kroah-Hartman return ret;
563ffc2825cSGreg Kroah-Hartman
564ffc2825cSGreg Kroah-Hartman break;
5656bb948c9STomas Winkler case MEI_FOP_DISCONNECT_RSP:
5666bb948c9STomas Winkler /* send disconnect resp */
5679d098192STomas Winkler ret = mei_cl_irq_disconnect_rsp(cl, cb, cmpl_list);
5686bb948c9STomas Winkler if (ret)
5696bb948c9STomas Winkler return ret;
57031a5ef24SAlexander Usyskin break;
57151678ccbSTomas Winkler
57251678ccbSTomas Winkler case MEI_FOP_NOTIFY_START:
57351678ccbSTomas Winkler case MEI_FOP_NOTIFY_STOP:
57451678ccbSTomas Winkler ret = mei_cl_irq_notify(cl, cb, cmpl_list);
57551678ccbSTomas Winkler if (ret)
57651678ccbSTomas Winkler return ret;
57751678ccbSTomas Winkler break;
578369aea84SAlexander Usyskin case MEI_FOP_DMA_MAP:
579369aea84SAlexander Usyskin ret = mei_cl_irq_dma_map(cl, cb, cmpl_list);
580369aea84SAlexander Usyskin if (ret)
581369aea84SAlexander Usyskin return ret;
582369aea84SAlexander Usyskin break;
583369aea84SAlexander Usyskin case MEI_FOP_DMA_UNMAP:
584369aea84SAlexander Usyskin ret = mei_cl_irq_dma_unmap(cl, cb, cmpl_list);
585369aea84SAlexander Usyskin if (ret)
586369aea84SAlexander Usyskin return ret;
587369aea84SAlexander Usyskin break;
588ffc2825cSGreg Kroah-Hartman default:
589ffc2825cSGreg Kroah-Hartman BUG();
590ffc2825cSGreg Kroah-Hartman }
591ffc2825cSGreg Kroah-Hartman
592ffc2825cSGreg Kroah-Hartman }
593ffc2825cSGreg Kroah-Hartman /* complete write list CB */
5942bf94cabSTomas Winkler dev_dbg(dev->dev, "complete write list cb.\n");
595962ff7bcSAlexander Usyskin list_for_each_entry_safe(cb, next, &dev->write_list, list) {
5966220d6a0STomas Winkler cl = cb->cl;
5979d098192STomas Winkler ret = mei_cl_irq_write(cl, cb, cmpl_list);
598ffc2825cSGreg Kroah-Hartman if (ret)
599ffc2825cSGreg Kroah-Hartman return ret;
600ffc2825cSGreg Kroah-Hartman }
601ffc2825cSGreg Kroah-Hartman return 0;
602ffc2825cSGreg Kroah-Hartman }
60340e0b67bSTomas Winkler EXPORT_SYMBOL_GPL(mei_irq_write_handler);
604ffc2825cSGreg Kroah-Hartman
605ffc2825cSGreg Kroah-Hartman
60618901357SAlexander Usyskin /**
60718901357SAlexander Usyskin * mei_connect_timeout - connect/disconnect timeouts
60818901357SAlexander Usyskin *
60918901357SAlexander Usyskin * @cl: host client
61018901357SAlexander Usyskin */
mei_connect_timeout(struct mei_cl * cl)61118901357SAlexander Usyskin static void mei_connect_timeout(struct mei_cl *cl)
61218901357SAlexander Usyskin {
61318901357SAlexander Usyskin struct mei_device *dev = cl->dev;
61418901357SAlexander Usyskin
61518901357SAlexander Usyskin if (cl->state == MEI_FILE_CONNECTING) {
61618901357SAlexander Usyskin if (dev->hbm_f_dot_supported) {
61718901357SAlexander Usyskin cl->state = MEI_FILE_DISCONNECT_REQUIRED;
61818901357SAlexander Usyskin wake_up(&cl->wait);
61918901357SAlexander Usyskin return;
62018901357SAlexander Usyskin }
62118901357SAlexander Usyskin }
62218901357SAlexander Usyskin mei_reset(dev);
62318901357SAlexander Usyskin }
624ffc2825cSGreg Kroah-Hartman
6251892fc2eSAlexander Usyskin #define MEI_STALL_TIMER_FREQ (2 * HZ)
6261892fc2eSAlexander Usyskin /**
6271892fc2eSAlexander Usyskin * mei_schedule_stall_timer - re-arm stall_timer work
6281892fc2eSAlexander Usyskin *
6291892fc2eSAlexander Usyskin * Schedule stall timer
6301892fc2eSAlexander Usyskin *
6311892fc2eSAlexander Usyskin * @dev: the device structure
6321892fc2eSAlexander Usyskin */
mei_schedule_stall_timer(struct mei_device * dev)6331892fc2eSAlexander Usyskin void mei_schedule_stall_timer(struct mei_device *dev)
6341892fc2eSAlexander Usyskin {
6351892fc2eSAlexander Usyskin schedule_delayed_work(&dev->timer_work, MEI_STALL_TIMER_FREQ);
6361892fc2eSAlexander Usyskin }
6371892fc2eSAlexander Usyskin
638ffc2825cSGreg Kroah-Hartman /**
639ffc2825cSGreg Kroah-Hartman * mei_timer - timer function.
640ffc2825cSGreg Kroah-Hartman *
641ffc2825cSGreg Kroah-Hartman * @work: pointer to the work_struct structure
642ffc2825cSGreg Kroah-Hartman *
643ffc2825cSGreg Kroah-Hartman */
mei_timer(struct work_struct * work)644ffc2825cSGreg Kroah-Hartman void mei_timer(struct work_struct *work)
645ffc2825cSGreg Kroah-Hartman {
64631f88f57STomas Winkler struct mei_cl *cl;
647ffc2825cSGreg Kroah-Hartman struct mei_device *dev = container_of(work,
648ffc2825cSGreg Kroah-Hartman struct mei_device, timer_work.work);
6491892fc2eSAlexander Usyskin bool reschedule_timer = false;
650ffc2825cSGreg Kroah-Hartman
651ffc2825cSGreg Kroah-Hartman mutex_lock(&dev->device_lock);
65266ae460bSTomas Winkler
65366ae460bSTomas Winkler /* Catch interrupt stalls during HBM init handshake */
65466ae460bSTomas Winkler if (dev->dev_state == MEI_DEV_INIT_CLIENTS &&
65566ae460bSTomas Winkler dev->hbm_state != MEI_HBM_IDLE) {
65666ae460bSTomas Winkler
657ffc2825cSGreg Kroah-Hartman if (dev->init_clients_timer) {
658ffc2825cSGreg Kroah-Hartman if (--dev->init_clients_timer == 0) {
6592bf94cabSTomas Winkler dev_err(dev->dev, "timer: init clients timeout hbm_state = %d.\n",
6609b0d5efcSTomas Winkler dev->hbm_state);
66133ec0826STomas Winkler mei_reset(dev);
662ffc2825cSGreg Kroah-Hartman goto out;
663ffc2825cSGreg Kroah-Hartman }
6641892fc2eSAlexander Usyskin reschedule_timer = true;
66566ae460bSTomas Winkler }
66666ae460bSTomas Winkler }
66766ae460bSTomas Winkler
66866ae460bSTomas Winkler if (dev->dev_state != MEI_DEV_ENABLED)
66966ae460bSTomas Winkler goto out;
67066ae460bSTomas Winkler
671ffc2825cSGreg Kroah-Hartman /*** connect/disconnect timeouts ***/
67231f88f57STomas Winkler list_for_each_entry(cl, &dev->file_list, link) {
67331f88f57STomas Winkler if (cl->timer_count) {
67431f88f57STomas Winkler if (--cl->timer_count == 0) {
6752bf94cabSTomas Winkler dev_err(dev->dev, "timer: connect/disconnect timeout.\n");
67618901357SAlexander Usyskin mei_connect_timeout(cl);
677ffc2825cSGreg Kroah-Hartman goto out;
678ffc2825cSGreg Kroah-Hartman }
6791892fc2eSAlexander Usyskin reschedule_timer = true;
680ffc2825cSGreg Kroah-Hartman }
681ffc2825cSGreg Kroah-Hartman }
682ffc2825cSGreg Kroah-Hartman
683ffc2825cSGreg Kroah-Hartman out:
6841892fc2eSAlexander Usyskin if (dev->dev_state != MEI_DEV_DISABLED && reschedule_timer)
6851892fc2eSAlexander Usyskin mei_schedule_stall_timer(dev);
6861892fc2eSAlexander Usyskin
687ffc2825cSGreg Kroah-Hartman mutex_unlock(&dev->device_lock);
688ffc2825cSGreg Kroah-Hartman }
689