#include #include #include #include #include #include "hvc_console.h" static int hvsi_send_packet(struct hvsi_priv *pv, struct hvsi_header *packet) { packet->seqno = cpu_to_be16(atomic_inc_return(&pv->seqno)); /* Assumes that always succeeds, works in practice */ return pv->put_chars(pv->termno, (char *)packet, packet->len); } static void hvsi_start_handshake(struct hvsi_priv *pv) { struct hvsi_query q; /* Reset state */ pv->established = 0; atomic_set(&pv->seqno, 0); pr_devel("HVSI@%x: Handshaking started\n", pv->termno); /* Send version query */ q.hdr.type = VS_QUERY_PACKET_HEADER; q.hdr.len = sizeof(struct hvsi_query); q.verb = cpu_to_be16(VSV_SEND_VERSION_NUMBER); hvsi_send_packet(pv, &q.hdr); } static int hvsi_send_close(struct hvsi_priv *pv) { struct hvsi_control ctrl; pv->established = 0; ctrl.hdr.type = VS_CONTROL_PACKET_HEADER; ctrl.hdr.len = sizeof(struct hvsi_control); ctrl.verb = cpu_to_be16(VSV_CLOSE_PROTOCOL); return hvsi_send_packet(pv, &ctrl.hdr); } static void hvsi_cd_change(struct hvsi_priv *pv, int cd) { if (cd) pv->mctrl |= TIOCM_CD; else { pv->mctrl &= ~TIOCM_CD; /* We copy the existing hvsi driver semantics * here which are to trigger a hangup when * we get a carrier loss. * Closing our connection to the server will * do just that. */ if (!pv->is_console && pv->opened) { pr_devel("HVSI@%x Carrier lost, hanging up !\n", pv->termno); hvsi_send_close(pv); } } } static void hvsi_got_control(struct hvsi_priv *pv) { struct hvsi_control *pkt = (struct hvsi_control *)pv->inbuf; switch (be16_to_cpu(pkt->verb)) { case VSV_CLOSE_PROTOCOL: /* We restart the handshaking */ hvsi_start_handshake(pv); break; case VSV_MODEM_CTL_UPDATE: /* Transition of carrier detect */ hvsi_cd_change(pv, be32_to_cpu(pkt->word) & HVSI_TSCD); break; } } static void hvsi_got_query(struct hvsi_priv *pv) { struct hvsi_query *pkt = (struct hvsi_query *)pv->inbuf; struct hvsi_query_response r; /* We only handle version queries */ if (be16_to_cpu(pkt->verb) != VSV_SEND_VERSION_NUMBER) return; pr_devel("HVSI@%x: Got version query, sending response...\n", pv->termno); /* Send version response */ r.hdr.type = VS_QUERY_RESPONSE_PACKET_HEADER; r.hdr.len = sizeof(struct hvsi_query_response); r.verb = cpu_to_be16(VSV_SEND_VERSION_NUMBER); r.u.version = HVSI_VERSION; r.query_seqno = pkt->hdr.seqno; hvsi_send_packet(pv, &r.hdr); /* Assume protocol is open now */ pv->established = 1; } static void hvsi_got_response(struct hvsi_priv *pv) { struct hvsi_query_response *r = (struct hvsi_query_response *)pv->inbuf; switch(r->verb) { case VSV_SEND_MODEM_CTL_STATUS: hvsi_cd_change(pv, be32_to_cpu(r->u.mctrl_word) & HVSI_TSCD); pv->mctrl_update = 1; break; } } static int hvsi_check_packet(struct hvsi_priv *pv) { u8 len, type; /* Check header validity. If it's invalid, we ditch * the whole buffer and hope we eventually resync */ if (pv->inbuf[0] < 0xfc) { pv->inbuf_len = pv->inbuf_pktlen = 0; return 0; } type = pv->inbuf[0]; len = pv->inbuf[1]; /* Packet incomplete ? */ if (pv->inbuf_len < len) return 0; pr_devel("HVSI@%x: Got packet type %x len %d bytes:\n", pv->termno, type, len); /* We have a packet, yay ! Handle it */ switch(type) { case VS_DATA_PACKET_HEADER: pv->inbuf_pktlen = len - 4; pv->inbuf_cur = 4; return 1; case VS_CONTROL_PACKET_HEADER: hvsi_got_control(pv); break; case VS_QUERY_PACKET_HEADER: hvsi_got_query(pv); break; case VS_QUERY_RESPONSE_PACKET_HEADER: hvsi_got_response(pv); break; } /* Swallow packet and retry */ pv->inbuf_len -= len; memmove(pv->inbuf, &pv->inbuf[len], pv->inbuf_len); return 1; } static int hvsi_get_packet(struct hvsi_priv *pv) { /* If we have room in the buffer, ask HV for more */ if (pv->inbuf_len < HVSI_INBUF_SIZE) pv->inbuf_len += pv->get_chars(pv->termno, &pv->inbuf[pv->inbuf_len], HVSI_INBUF_SIZE - pv->inbuf_len); /* * If we have at least 4 bytes in the buffer, check for * a full packet and retry */ if (pv->inbuf_len >= 4) return hvsi_check_packet(pv); return 0; } int hvsilib_get_chars(struct hvsi_priv *pv, char *buf, int count) { unsigned int tries, read = 0; if (WARN_ON(!pv)) return -ENXIO; /* If we aren't open, don't do anything in order to avoid races * with connection establishment. The hvc core will call this * before we have returned from notifier_add(), and we need to * avoid multiple users playing with the receive buffer */ if (!pv->opened) return 0; /* We try twice, once with what data we have and once more * after we try to fetch some more from the hypervisor */ for (tries = 1; count && tries < 2; tries++) { /* Consume existing data packet */ if (pv->inbuf_pktlen) { unsigned int l = min(count, (int)pv->inbuf_pktlen); memcpy(&buf[read], &pv->inbuf[pv->inbuf_cur], l); pv->inbuf_cur += l; pv->inbuf_pktlen -= l; count -= l; read += l; } if (count == 0) break; /* Data packet fully consumed, move down remaning data */ if (pv->inbuf_cur) { pv->inbuf_len -= pv->inbuf_cur; memmove(pv->inbuf, &pv->inbuf[pv->inbuf_cur], pv->inbuf_len); pv->inbuf_cur = 0; } /* Try to get another packet */ if (hvsi_get_packet(pv)) tries--; } if (!pv->established) { pr_devel("HVSI@%x: returning -EPIPE\n", pv->termno); return -EPIPE; } return read; } int hvsilib_put_chars(struct hvsi_priv *pv, const char *buf, int count) { struct hvsi_data dp; int rc, adjcount = min(count, HVSI_MAX_OUTGOING_DATA); if (WARN_ON(!pv)) return -ENODEV; dp.hdr.type = VS_DATA_PACKET_HEADER; dp.hdr.len = adjcount + sizeof(struct hvsi_header); memcpy(dp.data, buf, adjcount); rc = hvsi_send_packet(pv, &dp.hdr); if (rc <= 0) return rc; return adjcount; } static void maybe_msleep(unsigned long ms) { /* During early boot, IRQs are disabled, use mdelay */ if (irqs_disabled()) mdelay(ms); else msleep(ms); } int hvsilib_read_mctrl(struct hvsi_priv *pv) { struct hvsi_query q; int rc, timeout; pr_devel("HVSI@%x: Querying modem control status...\n", pv->termno); pv->mctrl_update = 0; q.hdr.type = VS_QUERY_PACKET_HEADER; q.hdr.len = sizeof(struct hvsi_query); q.verb = cpu_to_be16(VSV_SEND_MODEM_CTL_STATUS); rc = hvsi_send_packet(pv, &q.hdr); if (rc <= 0) { pr_devel("HVSI@%x: Error %d...\n", pv->termno, rc); return rc; } /* Try for up to 200ms */ for (timeout = 0; timeout < 20; timeout++) { if (!pv->established) return -ENXIO; if (pv->mctrl_update) return 0; if (!hvsi_get_packet(pv)) maybe_msleep(10); } return -EIO; } int hvsilib_write_mctrl(struct hvsi_priv *pv, int dtr) { struct hvsi_control ctrl; unsigned short mctrl; mctrl = pv->mctrl; if (dtr) mctrl |= TIOCM_DTR; else mctrl &= ~TIOCM_DTR; if (mctrl == pv->mctrl) return 0; pv->mctrl = mctrl; pr_devel("HVSI@%x: %s DTR...\n", pv->termno, dtr ? "Setting" : "Clearing"); ctrl.hdr.type = VS_CONTROL_PACKET_HEADER, ctrl.hdr.len = sizeof(struct hvsi_control); ctrl.verb = cpu_to_be16(VSV_SET_MODEM_CTL); ctrl.mask = cpu_to_be32(HVSI_TSDTR); ctrl.word = cpu_to_be32(dtr ? HVSI_TSDTR : 0); return hvsi_send_packet(pv, &ctrl.hdr); } void hvsilib_establish(struct hvsi_priv *pv) { int timeout; pr_devel("HVSI@%x: Establishing...\n", pv->termno); /* Try for up to 200ms, there can be a packet to * start the process waiting for us... */ for (timeout = 0; timeout < 20; timeout++) { if (pv->established) goto established; if (!hvsi_get_packet(pv)) maybe_msleep(10); } /* Failed, send a close connection packet just * in case */ pr_devel("HVSI@%x: ... sending close\n", pv->termno); hvsi_send_close(pv); /* Then restart handshake */ pr_devel("HVSI@%x: ... restarting handshake\n", pv->termno); hvsi_start_handshake(pv); pr_devel("HVSI@%x: ... waiting handshake\n", pv->termno); /* Try for up to 400ms */ for (timeout = 0; timeout < 40; timeout++) { if (pv->established) goto established; if (!hvsi_get_packet(pv)) maybe_msleep(10); } if (!pv->established) { pr_devel("HVSI@%x: Timeout handshaking, giving up !\n", pv->termno); return; } established: /* Query modem control lines */ pr_devel("HVSI@%x: ... established, reading mctrl\n", pv->termno); hvsilib_read_mctrl(pv); /* Set our own DTR */ pr_devel("HVSI@%x: ... setting mctrl\n", pv->termno); hvsilib_write_mctrl(pv, 1); /* Set the opened flag so reads are allowed */ wmb(); pv->opened = 1; } int hvsilib_open(struct hvsi_priv *pv, struct hvc_struct *hp) { pr_devel("HVSI@%x: open !\n", pv->termno); /* Keep track of the tty data structure */ pv->tty = tty_port_tty_get(&hp->port); hvsilib_establish(pv); return 0; } void hvsilib_close(struct hvsi_priv *pv, struct hvc_struct *hp) { unsigned long flags; pr_devel("HVSI@%x: close !\n", pv->termno); if (!pv->is_console) { pr_devel("HVSI@%x: Not a console, tearing down\n", pv->termno); /* Clear opened, synchronize with khvcd */ spin_lock_irqsave(&hp->lock, flags); pv->opened = 0; spin_unlock_irqrestore(&hp->lock, flags); /* Clear our own DTR */ if (!pv->tty || (pv->tty->termios.c_cflag & HUPCL)) hvsilib_write_mctrl(pv, 0); /* Tear down the connection */ hvsi_send_close(pv); } tty_kref_put(pv->tty); pv->tty = NULL; } void hvsilib_init(struct hvsi_priv *pv, int (*get_chars)(uint32_t termno, char *buf, int count), int (*put_chars)(uint32_t termno, const char *buf, int count), int termno, int is_console) { memset(pv, 0, sizeof(*pv)); pv->get_chars = get_chars; pv->put_chars = put_chars; pv->termno = termno; pv->is_console = is_console; } f0 kthread+0x127/0x130 ? process_one_work+0x4a0/0x4a0 ? kthread_stop+0x120/0x120 ret_from_fork+0x29/0x40 FIX kmalloc-128: Object at 0xffff92fb65ec2578 not freed Fixes: 3b24f7d67581 ("drm/atomic: Add struct drm_crtc_commit to track async updates") Fixes: 9626014258a5 ("drm/fence: add in-fences support") Cc: <stable@vger.kernel.org> # v4.8+ Cc: Daniel Vetter <daniel.vetter@ffwll.ch> Signed-off-by: Maarten Lankhorst <maarten.lankhorst@linux.intel.com> Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch> Reviewed-by: Gustavo Padovan <gustavo.padovan@collabora.com> Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch> Link: http://patchwork.freedesktop.org/patch/msgid/1485854725-27640-1-git-send-email-maarten.lankhorst@linux.intel.com
Diffstat (limited to 'net/nfc/hci/Kconfig')