1 /* 2 * ssi_protocol.c 3 * 4 * Implementation of the SSI McSAAB improved protocol. 5 * 6 * Copyright (C) 2010 Nokia Corporation. All rights reserved. 7 * Copyright (C) 2013 Sebastian Reichel <sre@kernel.org> 8 * 9 * Contact: Carlos Chinea <carlos.chinea@nokia.com> 10 * 11 * This program is free software; you can redistribute it and/or 12 * modify it under the terms of the GNU General Public License 13 * version 2 as published by the Free Software Foundation. 14 * 15 * This program is distributed in the hope that it will be useful, but 16 * WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 * General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program; if not, write to the Free Software 22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 23 * 02110-1301 USA 24 */ 25 26 #include <linux/atomic.h> 27 #include <linux/clk.h> 28 #include <linux/device.h> 29 #include <linux/err.h> 30 #include <linux/gpio.h> 31 #include <linux/if_ether.h> 32 #include <linux/if_arp.h> 33 #include <linux/if_phonet.h> 34 #include <linux/init.h> 35 #include <linux/irq.h> 36 #include <linux/list.h> 37 #include <linux/module.h> 38 #include <linux/netdevice.h> 39 #include <linux/notifier.h> 40 #include <linux/scatterlist.h> 41 #include <linux/skbuff.h> 42 #include <linux/slab.h> 43 #include <linux/spinlock.h> 44 #include <linux/timer.h> 45 #include <linux/hsi/hsi.h> 46 #include <linux/hsi/ssi_protocol.h> 47 48 void ssi_waketest(struct hsi_client *cl, unsigned int enable); 49 50 #define SSIP_TXQUEUE_LEN 100 51 #define SSIP_MAX_MTU 65535 52 #define SSIP_DEFAULT_MTU 4000 53 #define PN_MEDIA_SOS 21 54 #define SSIP_MIN_PN_HDR 6 /* FIXME: Revisit */ 55 #define SSIP_WDTOUT 2000 /* FIXME: has to be 500 msecs */ 56 #define SSIP_KATOUT 15 /* 15 msecs */ 57 #define SSIP_MAX_CMDS 5 /* Number of pre-allocated commands buffers */ 58 #define SSIP_BYTES_TO_FRAMES(x) ((((x) - 1) >> 2) + 1) 59 #define SSIP_CMT_LOADER_SYNC 0x11223344 60 /* 61 * SSI protocol command definitions 62 */ 63 #define SSIP_COMMAND(data) ((data) >> 28) 64 #define SSIP_PAYLOAD(data) ((data) & 0xfffffff) 65 /* Commands */ 66 #define SSIP_SW_BREAK 0 67 #define SSIP_BOOTINFO_REQ 1 68 #define SSIP_BOOTINFO_RESP 2 69 #define SSIP_WAKETEST_RESULT 3 70 #define SSIP_START_TRANS 4 71 #define SSIP_READY 5 72 /* Payloads */ 73 #define SSIP_DATA_VERSION(data) ((data) & 0xff) 74 #define SSIP_LOCAL_VERID 1 75 #define SSIP_WAKETEST_OK 0 76 #define SSIP_WAKETEST_FAILED 1 77 #define SSIP_PDU_LENGTH(data) (((data) >> 8) & 0xffff) 78 #define SSIP_MSG_ID(data) ((data) & 0xff) 79 /* Generic Command */ 80 #define SSIP_CMD(cmd, payload) (((cmd) << 28) | ((payload) & 0xfffffff)) 81 /* Commands for the control channel */ 82 #define SSIP_BOOTINFO_REQ_CMD(ver) \ 83 SSIP_CMD(SSIP_BOOTINFO_REQ, SSIP_DATA_VERSION(ver)) 84 #define SSIP_BOOTINFO_RESP_CMD(ver) \ 85 SSIP_CMD(SSIP_BOOTINFO_RESP, SSIP_DATA_VERSION(ver)) 86 #define SSIP_START_TRANS_CMD(pdulen, id) \ 87 SSIP_CMD(SSIP_START_TRANS, (((pdulen) << 8) | SSIP_MSG_ID(id))) 88 #define SSIP_READY_CMD SSIP_CMD(SSIP_READY, 0) 89 #define SSIP_SWBREAK_CMD SSIP_CMD(SSIP_SW_BREAK, 0) 90 91 #define SSIP_WAKETEST_FLAG 0 92 93 /* Main state machine states */ 94 enum { 95 INIT, 96 HANDSHAKE, 97 ACTIVE, 98 }; 99 100 /* Send state machine states */ 101 enum { 102 SEND_IDLE, 103 WAIT4READY, 104 SEND_READY, 105 SENDING, 106 SENDING_SWBREAK, 107 }; 108 109 /* Receive state machine states */ 110 enum { 111 RECV_IDLE, 112 RECV_READY, 113 RECEIVING, 114 }; 115 116 /** 117 * struct ssi_protocol - SSI protocol (McSAAB) data 118 * @main_state: Main state machine 119 * @send_state: TX state machine 120 * @recv_state: RX state machine 121 * @flags: Flags, currently only used to follow wake line test 122 * @rxid: RX data id 123 * @txid: TX data id 124 * @txqueue_len: TX queue length 125 * @tx_wd: TX watchdog 126 * @rx_wd: RX watchdog 127 * @keep_alive: Workaround for SSI HW bug 128 * @lock: To serialize access to this struct 129 * @netdev: Phonet network device 130 * @txqueue: TX data queue 131 * @cmdqueue: Queue of free commands 132 * @cl: HSI client own reference 133 * @link: Link for ssip_list 134 * @tx_usecount: Refcount to keep track the slaves that use the wake line 135 * @channel_id_cmd: HSI channel id for command stream 136 * @channel_id_data: HSI channel id for data stream 137 */ 138 struct ssi_protocol { 139 unsigned int main_state; 140 unsigned int send_state; 141 unsigned int recv_state; 142 unsigned long flags; 143 u8 rxid; 144 u8 txid; 145 unsigned int txqueue_len; 146 struct timer_list tx_wd; 147 struct timer_list rx_wd; 148 struct timer_list keep_alive; /* wake-up workaround */ 149 spinlock_t lock; 150 struct net_device *netdev; 151 struct list_head txqueue; 152 struct list_head cmdqueue; 153 struct work_struct work; 154 struct hsi_client *cl; 155 struct list_head link; 156 atomic_t tx_usecnt; 157 int channel_id_cmd; 158 int channel_id_data; 159 }; 160 161 /* List of ssi protocol instances */ 162 static LIST_HEAD(ssip_list); 163 164 static void ssip_rxcmd_complete(struct hsi_msg *msg); 165 166 static inline void ssip_set_cmd(struct hsi_msg *msg, u32 cmd) 167 { 168 u32 *data; 169 170 data = sg_virt(msg->sgt.sgl); 171 *data = cmd; 172 } 173 174 static inline u32 ssip_get_cmd(struct hsi_msg *msg) 175 { 176 u32 *data; 177 178 data = sg_virt(msg->sgt.sgl); 179 180 return *data; 181 } 182 183 static void ssip_skb_to_msg(struct sk_buff *skb, struct hsi_msg *msg) 184 { 185 skb_frag_t *frag; 186 struct scatterlist *sg; 187 int i; 188 189 BUG_ON(msg->sgt.nents != (unsigned int)(skb_shinfo(skb)->nr_frags + 1)); 190 191 sg = msg->sgt.sgl; 192 sg_set_buf(sg, skb->data, skb_headlen(skb)); 193 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { 194 sg = sg_next(sg); 195 BUG_ON(!sg); 196 frag = &skb_shinfo(skb)->frags[i]; 197 sg_set_page(sg, frag->page.p, frag->size, frag->page_offset); 198 } 199 } 200 201 static void ssip_free_data(struct hsi_msg *msg) 202 { 203 struct sk_buff *skb; 204 205 skb = msg->context; 206 pr_debug("free data: msg %p context %p skb %p\n", msg, msg->context, 207 skb); 208 msg->destructor = NULL; 209 dev_kfree_skb(skb); 210 hsi_free_msg(msg); 211 } 212 213 static struct hsi_msg *ssip_alloc_data(struct ssi_protocol *ssi, 214 struct sk_buff *skb, gfp_t flags) 215 { 216 struct hsi_msg *msg; 217 218 msg = hsi_alloc_msg(skb_shinfo(skb)->nr_frags + 1, flags); 219 if (!msg) 220 return NULL; 221 ssip_skb_to_msg(skb, msg); 222 msg->destructor = ssip_free_data; 223 msg->channel = ssi->channel_id_data; 224 msg->context = skb; 225 226 return msg; 227 } 228 229 static inline void ssip_release_cmd(struct hsi_msg *msg) 230 { 231 struct ssi_protocol *ssi = hsi_client_drvdata(msg->cl); 232 233 dev_dbg(&msg->cl->device, "Release cmd 0x%08x\n", ssip_get_cmd(msg)); 234 spin_lock_bh(&ssi->lock); 235 list_add_tail(&msg->link, &ssi->cmdqueue); 236 spin_unlock_bh(&ssi->lock); 237 } 238 239 static struct hsi_msg *ssip_claim_cmd(struct ssi_protocol *ssi) 240 { 241 struct hsi_msg *msg; 242 243 BUG_ON(list_empty(&ssi->cmdqueue)); 244 245 spin_lock_bh(&ssi->lock); 246 msg = list_first_entry(&ssi->cmdqueue, struct hsi_msg, link); 247 list_del(&msg->link); 248 spin_unlock_bh(&ssi->lock); 249 msg->destructor = ssip_release_cmd; 250 251 return msg; 252 } 253 254 static void ssip_free_cmds(struct ssi_protocol *ssi) 255 { 256 struct hsi_msg *msg, *tmp; 257 258 list_for_each_entry_safe(msg, tmp, &ssi->cmdqueue, link) { 259 list_del(&msg->link); 260 msg->destructor = NULL; 261 kfree(sg_virt(msg->sgt.sgl)); 262 hsi_free_msg(msg); 263 } 264 } 265 266 static int ssip_alloc_cmds(struct ssi_protocol *ssi) 267 { 268 struct hsi_msg *msg; 269 u32 *buf; 270 unsigned int i; 271 272 for (i = 0; i < SSIP_MAX_CMDS; i++) { 273 msg = hsi_alloc_msg(1, GFP_KERNEL); 274 if (!msg) 275 goto out; 276 buf = kmalloc(sizeof(*buf), GFP_KERNEL); 277 if (!buf) { 278 hsi_free_msg(msg); 279 goto out; 280 } 281 sg_init_one(msg->sgt.sgl, buf, sizeof(*buf)); 282 msg->channel = ssi->channel_id_cmd; 283 list_add_tail(&msg->link, &ssi->cmdqueue); 284 } 285 286 return 0; 287 out: 288 ssip_free_cmds(ssi); 289 290 return -ENOMEM; 291 } 292 293 static void ssip_set_rxstate(struct ssi_protocol *ssi, unsigned int state) 294 { 295 ssi->recv_state = state; 296 switch (state) { 297 case RECV_IDLE: 298 del_timer(&ssi->rx_wd); 299 if (ssi->send_state == SEND_IDLE) 300 del_timer(&ssi->keep_alive); 301 break; 302 case RECV_READY: 303 /* CMT speech workaround */ 304 if (atomic_read(&ssi->tx_usecnt)) 305 break; 306 /* Otherwise fall through */ 307 case RECEIVING: 308 mod_timer(&ssi->keep_alive, jiffies + 309 msecs_to_jiffies(SSIP_KATOUT)); 310 mod_timer(&ssi->rx_wd, jiffies + msecs_to_jiffies(SSIP_WDTOUT)); 311 break; 312 default: 313 break; 314 } 315 } 316 317 static void ssip_set_txstate(struct ssi_protocol *ssi, unsigned int state) 318 { 319 ssi->send_state = state; 320 switch (state) { 321 case SEND_IDLE: 322 case SEND_READY: 323 del_timer(&ssi->tx_wd); 324 if (ssi->recv_state == RECV_IDLE) 325 del_timer(&ssi->keep_alive); 326 break; 327 case WAIT4READY: 328 case SENDING: 329 case SENDING_SWBREAK: 330 mod_timer(&ssi->keep_alive, 331 jiffies + msecs_to_jiffies(SSIP_KATOUT)); 332 mod_timer(&ssi->tx_wd, jiffies + msecs_to_jiffies(SSIP_WDTOUT)); 333 break; 334 default: 335 break; 336 } 337 } 338 339 struct hsi_client *ssip_slave_get_master(struct hsi_client *slave) 340 { 341 struct hsi_client *master = ERR_PTR(-ENODEV); 342 struct ssi_protocol *ssi; 343 344 list_for_each_entry(ssi, &ssip_list, link) 345 if (slave->device.parent == ssi->cl->device.parent) { 346 master = ssi->cl; 347 break; 348 } 349 350 return master; 351 } 352 EXPORT_SYMBOL_GPL(ssip_slave_get_master); 353 354 int ssip_slave_start_tx(struct hsi_client *master) 355 { 356 struct ssi_protocol *ssi = hsi_client_drvdata(master); 357 358 dev_dbg(&master->device, "start TX %d\n", atomic_read(&ssi->tx_usecnt)); 359 spin_lock_bh(&ssi->lock); 360 if (ssi->send_state == SEND_IDLE) { 361 ssip_set_txstate(ssi, WAIT4READY); 362 hsi_start_tx(master); 363 } 364 spin_unlock_bh(&ssi->lock); 365 atomic_inc(&ssi->tx_usecnt); 366 367 return 0; 368 } 369 EXPORT_SYMBOL_GPL(ssip_slave_start_tx); 370 371 int ssip_slave_stop_tx(struct hsi_client *master) 372 { 373 struct ssi_protocol *ssi = hsi_client_drvdata(master); 374 375 WARN_ON_ONCE(atomic_read(&ssi->tx_usecnt) == 0); 376 377 if (atomic_dec_and_test(&ssi->tx_usecnt)) { 378 spin_lock_bh(&ssi->lock); 379 if ((ssi->send_state == SEND_READY) || 380 (ssi->send_state == WAIT4READY)) { 381 ssip_set_txstate(ssi, SEND_IDLE); 382 hsi_stop_tx(master); 383 } 384 spin_unlock_bh(&ssi->lock); 385 } 386 dev_dbg(&master->device, "stop TX %d\n", atomic_read(&ssi->tx_usecnt)); 387 388 return 0; 389 } 390 EXPORT_SYMBOL_GPL(ssip_slave_stop_tx); 391 392 int ssip_slave_running(struct hsi_client *master) 393 { 394 struct ssi_protocol *ssi = hsi_client_drvdata(master); 395 return netif_running(ssi->netdev); 396 } 397 EXPORT_SYMBOL_GPL(ssip_slave_running); 398 399 static void ssip_reset(struct hsi_client *cl) 400 { 401 struct ssi_protocol *ssi = hsi_client_drvdata(cl); 402 struct list_head *head, *tmp; 403 struct hsi_msg *msg; 404 405 if (netif_running(ssi->netdev)) 406 netif_carrier_off(ssi->netdev); 407 hsi_flush(cl); 408 spin_lock_bh(&ssi->lock); 409 if (ssi->send_state != SEND_IDLE) 410 hsi_stop_tx(cl); 411 spin_unlock_bh(&ssi->lock); 412 if (test_and_clear_bit(SSIP_WAKETEST_FLAG, &ssi->flags)) 413 ssi_waketest(cl, 0); /* FIXME: To be removed */ 414 spin_lock_bh(&ssi->lock); 415 del_timer(&ssi->rx_wd); 416 del_timer(&ssi->tx_wd); 417 del_timer(&ssi->keep_alive); 418 ssi->main_state = 0; 419 ssi->send_state = 0; 420 ssi->recv_state = 0; 421 ssi->flags = 0; 422 ssi->rxid = 0; 423 ssi->txid = 0; 424 list_for_each_safe(head, tmp, &ssi->txqueue) { 425 msg = list_entry(head, struct hsi_msg, link); 426 dev_dbg(&cl->device, "Pending TX data\n"); 427 list_del(head); 428 ssip_free_data(msg); 429 } 430 ssi->txqueue_len = 0; 431 spin_unlock_bh(&ssi->lock); 432 } 433 434 static void ssip_dump_state(struct hsi_client *cl) 435 { 436 struct ssi_protocol *ssi = hsi_client_drvdata(cl); 437 struct hsi_msg *msg; 438 439 spin_lock_bh(&ssi->lock); 440 dev_err(&cl->device, "Main state: %d\n", ssi->main_state); 441 dev_err(&cl->device, "Recv state: %d\n", ssi->recv_state); 442 dev_err(&cl->device, "Send state: %d\n", ssi->send_state); 443 dev_err(&cl->device, "CMT %s\n", (ssi->main_state == ACTIVE) ? 444 "Online" : "Offline"); 445 dev_err(&cl->device, "Wake test %d\n", 446 test_bit(SSIP_WAKETEST_FLAG, &ssi->flags)); 447 dev_err(&cl->device, "Data RX id: %d\n", ssi->rxid); 448 dev_err(&cl->device, "Data TX id: %d\n", ssi->txid); 449 450 list_for_each_entry(msg, &ssi->txqueue, link) 451 dev_err(&cl->device, "pending TX data (%p)\n", msg); 452 spin_unlock_bh(&ssi->lock); 453 } 454 455 static void ssip_error(struct hsi_client *cl) 456 { 457 struct ssi_protocol *ssi = hsi_client_drvdata(cl); 458 struct hsi_msg *msg; 459 460 ssip_dump_state(cl); 461 ssip_reset(cl); 462 msg = ssip_claim_cmd(ssi); 463 msg->complete = ssip_rxcmd_complete; 464 hsi_async_read(cl, msg); 465 } 466 467 static void ssip_keep_alive(struct timer_list *t) 468 { 469 struct ssi_protocol *ssi = from_timer(ssi, t, keep_alive); 470 struct hsi_client *cl = ssi->cl; 471 472 dev_dbg(&cl->device, "Keep alive kick in: m(%d) r(%d) s(%d)\n", 473 ssi->main_state, ssi->recv_state, ssi->send_state); 474 475 spin_lock(&ssi->lock); 476 if (ssi->recv_state == RECV_IDLE) 477 switch (ssi->send_state) { 478 case SEND_READY: 479 if (atomic_read(&ssi->tx_usecnt) == 0) 480 break; 481 /* 482 * Fall through. Workaround for cmt-speech 483 * in that case we relay on audio timers. 484 */ 485 case SEND_IDLE: 486 spin_unlock(&ssi->lock); 487 return; 488 } 489 mod_timer(&ssi->keep_alive, jiffies + msecs_to_jiffies(SSIP_KATOUT)); 490 spin_unlock(&ssi->lock); 491 } 492 493 static void ssip_rx_wd(struct timer_list *t) 494 { 495 struct ssi_protocol *ssi = from_timer(ssi, t, rx_wd); 496 struct hsi_client *cl = ssi->cl; 497 498 dev_err(&cl->device, "Watchdog triggered\n"); 499 ssip_error(cl); 500 } 501 502 static void ssip_tx_wd(struct timer_list *t) 503 { 504 struct ssi_protocol *ssi = from_timer(ssi, t, tx_wd); 505 struct hsi_client *cl = ssi->cl; 506 507 dev_err(&cl->device, "Watchdog triggered\n"); 508 ssip_error(cl); 509 } 510 511 static void ssip_send_bootinfo_req_cmd(struct hsi_client *cl) 512 { 513 struct ssi_protocol *ssi = hsi_client_drvdata(cl); 514 struct hsi_msg *msg; 515 516 dev_dbg(&cl->device, "Issuing BOOT INFO REQ command\n"); 517 msg = ssip_claim_cmd(ssi); 518 ssip_set_cmd(msg, SSIP_BOOTINFO_REQ_CMD(SSIP_LOCAL_VERID)); 519 msg->complete = ssip_release_cmd; 520 hsi_async_write(cl, msg); 521 dev_dbg(&cl->device, "Issuing RX command\n"); 522 msg = ssip_claim_cmd(ssi); 523 msg->complete = ssip_rxcmd_complete; 524 hsi_async_read(cl, msg); 525 } 526 527 static void ssip_start_rx(struct hsi_client *cl) 528 { 529 struct ssi_protocol *ssi = hsi_client_drvdata(cl); 530 struct hsi_msg *msg; 531 532 dev_dbg(&cl->device, "RX start M(%d) R(%d)\n", ssi->main_state, 533 ssi->recv_state); 534 spin_lock_bh(&ssi->lock); 535 /* 536 * We can have two UP events in a row due to a short low 537 * high transition. Therefore we need to ignore the sencond UP event. 538 */ 539 if ((ssi->main_state != ACTIVE) || (ssi->recv_state == RECV_READY)) { 540 spin_unlock_bh(&ssi->lock); 541 return; 542 } 543 ssip_set_rxstate(ssi, RECV_READY); 544 spin_unlock_bh(&ssi->lock); 545 546 msg = ssip_claim_cmd(ssi); 547 ssip_set_cmd(msg, SSIP_READY_CMD); 548 msg->complete = ssip_release_cmd; 549 dev_dbg(&cl->device, "Send READY\n"); 550 hsi_async_write(cl, msg); 551 } 552 553 static void ssip_stop_rx(struct hsi_client *cl) 554 { 555 struct ssi_protocol *ssi = hsi_client_drvdata(cl); 556 557 dev_dbg(&cl->device, "RX stop M(%d)\n", ssi->main_state); 558 spin_lock_bh(&ssi->lock); 559 if (likely(ssi->main_state == ACTIVE)) 560 ssip_set_rxstate(ssi, RECV_IDLE); 561 spin_unlock_bh(&ssi->lock); 562 } 563 564 static void ssip_free_strans(struct hsi_msg *msg) 565 { 566 ssip_free_data(msg->context); 567 ssip_release_cmd(msg); 568 } 569 570 static void ssip_strans_complete(struct hsi_msg *msg) 571 { 572 struct hsi_client *cl = msg->cl; 573 struct ssi_protocol *ssi = hsi_client_drvdata(cl); 574 struct hsi_msg *data; 575 576 data = msg->context; 577 ssip_release_cmd(msg); 578 spin_lock_bh(&ssi->lock); 579 ssip_set_txstate(ssi, SENDING); 580 spin_unlock_bh(&ssi->lock); 581 hsi_async_write(cl, data); 582 } 583 584 static int ssip_xmit(struct hsi_client *cl) 585 { 586 struct ssi_protocol *ssi = hsi_client_drvdata(cl); 587 struct hsi_msg *msg, *dmsg; 588 struct sk_buff *skb; 589 590 spin_lock_bh(&ssi->lock); 591 if (list_empty(&ssi->txqueue)) { 592 spin_unlock_bh(&ssi->lock); 593 return 0; 594 } 595 dmsg = list_first_entry(&ssi->txqueue, struct hsi_msg, link); 596 list_del(&dmsg->link); 597 ssi->txqueue_len--; 598 spin_unlock_bh(&ssi->lock); 599 600 msg = ssip_claim_cmd(ssi); 601 skb = dmsg->context; 602 msg->context = dmsg; 603 msg->complete = ssip_strans_complete; 604 msg->destructor = ssip_free_strans; 605 606 spin_lock_bh(&ssi->lock); 607 ssip_set_cmd(msg, SSIP_START_TRANS_CMD(SSIP_BYTES_TO_FRAMES(skb->len), 608 ssi->txid)); 609 ssi->txid++; 610 ssip_set_txstate(ssi, SENDING); 611 spin_unlock_bh(&ssi->lock); 612 613 dev_dbg(&cl->device, "Send STRANS (%d frames)\n", 614 SSIP_BYTES_TO_FRAMES(skb->len)); 615 616 return hsi_async_write(cl, msg); 617 } 618 619 /* In soft IRQ context */ 620 static void ssip_pn_rx(struct sk_buff *skb) 621 { 622 struct net_device *dev = skb->dev; 623 624 if (unlikely(!netif_running(dev))) { 625 dev_dbg(&dev->dev, "Drop RX packet\n"); 626 dev->stats.rx_dropped++; 627 dev_kfree_skb(skb); 628 return; 629 } 630 if (unlikely(!pskb_may_pull(skb, SSIP_MIN_PN_HDR))) { 631 dev_dbg(&dev->dev, "Error drop RX packet\n"); 632 dev->stats.rx_errors++; 633 dev->stats.rx_length_errors++; 634 dev_kfree_skb(skb); 635 return; 636 } 637 dev->stats.rx_packets++; 638 dev->stats.rx_bytes += skb->len; 639 640 /* length field is exchanged in network byte order */ 641 ((u16 *)skb->data)[2] = ntohs(((u16 *)skb->data)[2]); 642 dev_dbg(&dev->dev, "RX length fixed (%04x -> %u)\n", 643 ((u16 *)skb->data)[2], ntohs(((u16 *)skb->data)[2])); 644 645 skb->protocol = htons(ETH_P_PHONET); 646 skb_reset_mac_header(skb); 647 __skb_pull(skb, 1); 648 netif_rx(skb); 649 } 650 651 static void ssip_rx_data_complete(struct hsi_msg *msg) 652 { 653 struct hsi_client *cl = msg->cl; 654 struct ssi_protocol *ssi = hsi_client_drvdata(cl); 655 struct sk_buff *skb; 656 657 if (msg->status == HSI_STATUS_ERROR) { 658 dev_err(&cl->device, "RX data error\n"); 659 ssip_free_data(msg); 660 ssip_error(cl); 661 return; 662 } 663 del_timer(&ssi->rx_wd); /* FIXME: Revisit */ 664 skb = msg->context; 665 ssip_pn_rx(skb); 666 hsi_free_msg(msg); 667 } 668 669 static void ssip_rx_bootinforeq(struct hsi_client *cl, u32 cmd) 670 { 671 struct ssi_protocol *ssi = hsi_client_drvdata(cl); 672 struct hsi_msg *msg; 673 674 /* Workaroud: Ignore CMT Loader message leftover */ 675 if (cmd == SSIP_CMT_LOADER_SYNC) 676 return; 677 678 switch (ssi->main_state) { 679 case ACTIVE: 680 dev_err(&cl->device, "Boot info req on active state\n"); 681 ssip_error(cl); 682 /* Fall through */ 683 case INIT: 684 case HANDSHAKE: 685 spin_lock_bh(&ssi->lock); 686 ssi->main_state = HANDSHAKE; 687 spin_unlock_bh(&ssi->lock); 688 689 if (!test_and_set_bit(SSIP_WAKETEST_FLAG, &ssi->flags)) 690 ssi_waketest(cl, 1); /* FIXME: To be removed */ 691 692 spin_lock_bh(&ssi->lock); 693 /* Start boot handshake watchdog */ 694 mod_timer(&ssi->tx_wd, jiffies + msecs_to_jiffies(SSIP_WDTOUT)); 695 spin_unlock_bh(&ssi->lock); 696 dev_dbg(&cl->device, "Send BOOTINFO_RESP\n"); 697 if (SSIP_DATA_VERSION(cmd) != SSIP_LOCAL_VERID) 698 dev_warn(&cl->device, "boot info req verid mismatch\n"); 699 msg = ssip_claim_cmd(ssi); 700 ssip_set_cmd(msg, SSIP_BOOTINFO_RESP_CMD(SSIP_LOCAL_VERID)); 701 msg->complete = ssip_release_cmd; 702 hsi_async_write(cl, msg); 703 break; 704 default: 705 dev_dbg(&cl->device, "Wrong state M(%d)\n", ssi->main_state); 706 break; 707 } 708 } 709 710 static void ssip_rx_bootinforesp(struct hsi_client *cl, u32 cmd) 711 { 712 struct ssi_protocol *ssi = hsi_client_drvdata(cl); 713 714 if (SSIP_DATA_VERSION(cmd) != SSIP_LOCAL_VERID) 715 dev_warn(&cl->device, "boot info resp verid mismatch\n"); 716 717 spin_lock_bh(&ssi->lock); 718 if (ssi->main_state != ACTIVE) 719 /* Use tx_wd as a boot watchdog in non ACTIVE state */ 720 mod_timer(&ssi->tx_wd, jiffies + msecs_to_jiffies(SSIP_WDTOUT)); 721 else 722 dev_dbg(&cl->device, "boot info resp ignored M(%d)\n", 723 ssi->main_state); 724 spin_unlock_bh(&ssi->lock); 725 } 726 727 static void ssip_rx_waketest(struct hsi_client *cl, u32 cmd) 728 { 729 struct ssi_protocol *ssi = hsi_client_drvdata(cl); 730 unsigned int wkres = SSIP_PAYLOAD(cmd); 731 732 spin_lock_bh(&ssi->lock); 733 if (ssi->main_state != HANDSHAKE) { 734 dev_dbg(&cl->device, "wake lines test ignored M(%d)\n", 735 ssi->main_state); 736 spin_unlock_bh(&ssi->lock); 737 return; 738 } 739 spin_unlock_bh(&ssi->lock); 740 741 if (test_and_clear_bit(SSIP_WAKETEST_FLAG, &ssi->flags)) 742 ssi_waketest(cl, 0); /* FIXME: To be removed */ 743 744 spin_lock_bh(&ssi->lock); 745 ssi->main_state = ACTIVE; 746 del_timer(&ssi->tx_wd); /* Stop boot handshake timer */ 747 spin_unlock_bh(&ssi->lock); 748 749 dev_notice(&cl->device, "WAKELINES TEST %s\n", 750 wkres & SSIP_WAKETEST_FAILED ? "FAILED" : "OK"); 751 if (wkres & SSIP_WAKETEST_FAILED) { 752 ssip_error(cl); 753 return; 754 } 755 dev_dbg(&cl->device, "CMT is ONLINE\n"); 756 netif_wake_queue(ssi->netdev); 757 netif_carrier_on(ssi->netdev); 758 } 759 760 static void ssip_rx_ready(struct hsi_client *cl) 761 { 762 struct ssi_protocol *ssi = hsi_client_drvdata(cl); 763 764 spin_lock_bh(&ssi->lock); 765 if (unlikely(ssi->main_state != ACTIVE)) { 766 dev_dbg(&cl->device, "READY on wrong state: S(%d) M(%d)\n", 767 ssi->send_state, ssi->main_state); 768 spin_unlock_bh(&ssi->lock); 769 return; 770 } 771 if (ssi->send_state != WAIT4READY) { 772 dev_dbg(&cl->device, "Ignore spurious READY command\n"); 773 spin_unlock_bh(&ssi->lock); 774 return; 775 } 776 ssip_set_txstate(ssi, SEND_READY); 777 spin_unlock_bh(&ssi->lock); 778 ssip_xmit(cl); 779 } 780 781 static void ssip_rx_strans(struct hsi_client *cl, u32 cmd) 782 { 783 struct ssi_protocol *ssi = hsi_client_drvdata(cl); 784 struct sk_buff *skb; 785 struct hsi_msg *msg; 786 int len = SSIP_PDU_LENGTH(cmd); 787 788 dev_dbg(&cl->device, "RX strans: %d frames\n", len); 789 spin_lock_bh(&ssi->lock); 790 if (unlikely(ssi->main_state != ACTIVE)) { 791 dev_err(&cl->device, "START TRANS wrong state: S(%d) M(%d)\n", 792 ssi->send_state, ssi->main_state); 793 spin_unlock_bh(&ssi->lock); 794 return; 795 } 796 ssip_set_rxstate(ssi, RECEIVING); 797 if (unlikely(SSIP_MSG_ID(cmd) != ssi->rxid)) { 798 dev_err(&cl->device, "START TRANS id %d expected %d\n", 799 SSIP_MSG_ID(cmd), ssi->rxid); 800 spin_unlock_bh(&ssi->lock); 801 goto out1; 802 } 803 ssi->rxid++; 804 spin_unlock_bh(&ssi->lock); 805 skb = netdev_alloc_skb(ssi->netdev, len * 4); 806 if (unlikely(!skb)) { 807 dev_err(&cl->device, "No memory for rx skb\n"); 808 goto out1; 809 } 810 skb->dev = ssi->netdev; 811 skb_put(skb, len * 4); 812 msg = ssip_alloc_data(ssi, skb, GFP_ATOMIC); 813 if (unlikely(!msg)) { 814 dev_err(&cl->device, "No memory for RX data msg\n"); 815 goto out2; 816 } 817 msg->complete = ssip_rx_data_complete; 818 hsi_async_read(cl, msg); 819 820 return; 821 out2: 822 dev_kfree_skb(skb); 823 out1: 824 ssip_error(cl); 825 } 826 827 static void ssip_rxcmd_complete(struct hsi_msg *msg) 828 { 829 struct hsi_client *cl = msg->cl; 830 u32 cmd = ssip_get_cmd(msg); 831 unsigned int cmdid = SSIP_COMMAND(cmd); 832 833 if (msg->status == HSI_STATUS_ERROR) { 834 dev_err(&cl->device, "RX error detected\n"); 835 ssip_release_cmd(msg); 836 ssip_error(cl); 837 return; 838 } 839 hsi_async_read(cl, msg); 840 dev_dbg(&cl->device, "RX cmd: 0x%08x\n", cmd); 841 switch (cmdid) { 842 case SSIP_SW_BREAK: 843 /* Ignored */ 844 break; 845 case SSIP_BOOTINFO_REQ: 846 ssip_rx_bootinforeq(cl, cmd); 847 break; 848 case SSIP_BOOTINFO_RESP: 849 ssip_rx_bootinforesp(cl, cmd); 850 break; 851 case SSIP_WAKETEST_RESULT: 852 ssip_rx_waketest(cl, cmd); 853 break; 854 case SSIP_START_TRANS: 855 ssip_rx_strans(cl, cmd); 856 break; 857 case SSIP_READY: 858 ssip_rx_ready(cl); 859 break; 860 default: 861 dev_warn(&cl->device, "command 0x%08x not supported\n", cmd); 862 break; 863 } 864 } 865 866 static void ssip_swbreak_complete(struct hsi_msg *msg) 867 { 868 struct hsi_client *cl = msg->cl; 869 struct ssi_protocol *ssi = hsi_client_drvdata(cl); 870 871 ssip_release_cmd(msg); 872 spin_lock_bh(&ssi->lock); 873 if (list_empty(&ssi->txqueue)) { 874 if (atomic_read(&ssi->tx_usecnt)) { 875 ssip_set_txstate(ssi, SEND_READY); 876 } else { 877 ssip_set_txstate(ssi, SEND_IDLE); 878 hsi_stop_tx(cl); 879 } 880 spin_unlock_bh(&ssi->lock); 881 } else { 882 spin_unlock_bh(&ssi->lock); 883 ssip_xmit(cl); 884 } 885 netif_wake_queue(ssi->netdev); 886 } 887 888 static void ssip_tx_data_complete(struct hsi_msg *msg) 889 { 890 struct hsi_client *cl = msg->cl; 891 struct ssi_protocol *ssi = hsi_client_drvdata(cl); 892 struct hsi_msg *cmsg; 893 894 if (msg->status == HSI_STATUS_ERROR) { 895 dev_err(&cl->device, "TX data error\n"); 896 ssip_error(cl); 897 goto out; 898 } 899 spin_lock_bh(&ssi->lock); 900 if (list_empty(&ssi->txqueue)) { 901 ssip_set_txstate(ssi, SENDING_SWBREAK); 902 spin_unlock_bh(&ssi->lock); 903 cmsg = ssip_claim_cmd(ssi); 904 ssip_set_cmd(cmsg, SSIP_SWBREAK_CMD); 905 cmsg->complete = ssip_swbreak_complete; 906 dev_dbg(&cl->device, "Send SWBREAK\n"); 907 hsi_async_write(cl, cmsg); 908 } else { 909 spin_unlock_bh(&ssi->lock); 910 ssip_xmit(cl); 911 } 912 out: 913 ssip_free_data(msg); 914 } 915 916 static void ssip_port_event(struct hsi_client *cl, unsigned long event) 917 { 918 switch (event) { 919 case HSI_EVENT_START_RX: 920 ssip_start_rx(cl); 921 break; 922 case HSI_EVENT_STOP_RX: 923 ssip_stop_rx(cl); 924 break; 925 default: 926 return; 927 } 928 } 929 930 static int ssip_pn_open(struct net_device *dev) 931 { 932 struct hsi_client *cl = to_hsi_client(dev->dev.parent); 933 struct ssi_protocol *ssi = hsi_client_drvdata(cl); 934 int err; 935 936 err = hsi_claim_port(cl, 1); 937 if (err < 0) { 938 dev_err(&cl->device, "SSI port already claimed\n"); 939 return err; 940 } 941 err = hsi_register_port_event(cl, ssip_port_event); 942 if (err < 0) { 943 dev_err(&cl->device, "Register HSI port event failed (%d)\n", 944 err); 945 return err; 946 } 947 dev_dbg(&cl->device, "Configuring SSI port\n"); 948 hsi_setup(cl); 949 950 if (!test_and_set_bit(SSIP_WAKETEST_FLAG, &ssi->flags)) 951 ssi_waketest(cl, 1); /* FIXME: To be removed */ 952 953 spin_lock_bh(&ssi->lock); 954 ssi->main_state = HANDSHAKE; 955 spin_unlock_bh(&ssi->lock); 956 957 ssip_send_bootinfo_req_cmd(cl); 958 959 return 0; 960 } 961 962 static int ssip_pn_stop(struct net_device *dev) 963 { 964 struct hsi_client *cl = to_hsi_client(dev->dev.parent); 965 966 ssip_reset(cl); 967 hsi_unregister_port_event(cl); 968 hsi_release_port(cl); 969 970 return 0; 971 } 972 973 static void ssip_xmit_work(struct work_struct *work) 974 { 975 struct ssi_protocol *ssi = 976 container_of(work, struct ssi_protocol, work); 977 struct hsi_client *cl = ssi->cl; 978 979 ssip_xmit(cl); 980 } 981 982 static int ssip_pn_xmit(struct sk_buff *skb, struct net_device *dev) 983 { 984 struct hsi_client *cl = to_hsi_client(dev->dev.parent); 985 struct ssi_protocol *ssi = hsi_client_drvdata(cl); 986 struct hsi_msg *msg; 987 988 if ((skb->protocol != htons(ETH_P_PHONET)) || 989 (skb->len < SSIP_MIN_PN_HDR)) 990 goto drop; 991 /* Pad to 32-bits - FIXME: Revisit*/ 992 if ((skb->len & 3) && skb_pad(skb, 4 - (skb->len & 3))) 993 goto inc_dropped; 994 995 /* 996 * Modem sends Phonet messages over SSI with its own endianness. 997 * Assume that modem has the same endianness as we do. 998 */ 999 if (skb_cow_head(skb, 0)) 1000 goto drop; 1001 1002 /* length field is exchanged in network byte order */ 1003 ((u16 *)skb->data)[2] = htons(((u16 *)skb->data)[2]); 1004 1005 msg = ssip_alloc_data(ssi, skb, GFP_ATOMIC); 1006 if (!msg) { 1007 dev_dbg(&cl->device, "Dropping tx data: No memory\n"); 1008 goto drop; 1009 } 1010 msg->complete = ssip_tx_data_complete; 1011 1012 spin_lock_bh(&ssi->lock); 1013 if (unlikely(ssi->main_state != ACTIVE)) { 1014 spin_unlock_bh(&ssi->lock); 1015 dev_dbg(&cl->device, "Dropping tx data: CMT is OFFLINE\n"); 1016 goto drop2; 1017 } 1018 list_add_tail(&msg->link, &ssi->txqueue); 1019 ssi->txqueue_len++; 1020 if (dev->tx_queue_len < ssi->txqueue_len) { 1021 dev_info(&cl->device, "TX queue full %d\n", ssi->txqueue_len); 1022 netif_stop_queue(dev); 1023 } 1024 if (ssi->send_state == SEND_IDLE) { 1025 ssip_set_txstate(ssi, WAIT4READY); 1026 spin_unlock_bh(&ssi->lock); 1027 dev_dbg(&cl->device, "Start TX qlen %d\n", ssi->txqueue_len); 1028 hsi_start_tx(cl); 1029 } else if (ssi->send_state == SEND_READY) { 1030 /* Needed for cmt-speech workaround */ 1031 dev_dbg(&cl->device, "Start TX on SEND READY qlen %d\n", 1032 ssi->txqueue_len); 1033 spin_unlock_bh(&ssi->lock); 1034 schedule_work(&ssi->work); 1035 } else { 1036 spin_unlock_bh(&ssi->lock); 1037 } 1038 dev->stats.tx_packets++; 1039 dev->stats.tx_bytes += skb->len; 1040 1041 return 0; 1042 drop2: 1043 hsi_free_msg(msg); 1044 drop: 1045 dev_kfree_skb(skb); 1046 inc_dropped: 1047 dev->stats.tx_dropped++; 1048 1049 return 0; 1050 } 1051 1052 /* CMT reset event handler */ 1053 void ssip_reset_event(struct hsi_client *master) 1054 { 1055 struct ssi_protocol *ssi = hsi_client_drvdata(master); 1056 dev_err(&ssi->cl->device, "CMT reset detected!\n"); 1057 ssip_error(ssi->cl); 1058 } 1059 EXPORT_SYMBOL_GPL(ssip_reset_event); 1060 1061 static const struct net_device_ops ssip_pn_ops = { 1062 .ndo_open = ssip_pn_open, 1063 .ndo_stop = ssip_pn_stop, 1064 .ndo_start_xmit = ssip_pn_xmit, 1065 }; 1066 1067 static void ssip_pn_setup(struct net_device *dev) 1068 { 1069 dev->features = 0; 1070 dev->netdev_ops = &ssip_pn_ops; 1071 dev->type = ARPHRD_PHONET; 1072 dev->flags = IFF_POINTOPOINT | IFF_NOARP; 1073 dev->mtu = SSIP_DEFAULT_MTU; 1074 dev->hard_header_len = 1; 1075 dev->dev_addr[0] = PN_MEDIA_SOS; 1076 dev->addr_len = 1; 1077 dev->tx_queue_len = SSIP_TXQUEUE_LEN; 1078 1079 dev->needs_free_netdev = true; 1080 dev->header_ops = &phonet_header_ops; 1081 } 1082 1083 static int ssi_protocol_probe(struct device *dev) 1084 { 1085 static const char ifname[] = "phonet%d"; 1086 struct hsi_client *cl = to_hsi_client(dev); 1087 struct ssi_protocol *ssi; 1088 int err; 1089 1090 ssi = kzalloc(sizeof(*ssi), GFP_KERNEL); 1091 if (!ssi) 1092 return -ENOMEM; 1093 1094 spin_lock_init(&ssi->lock); 1095 timer_setup(&ssi->rx_wd, ssip_rx_wd, TIMER_DEFERRABLE); 1096 timer_setup(&ssi->tx_wd, ssip_tx_wd, TIMER_DEFERRABLE); 1097 timer_setup(&ssi->keep_alive, ssip_keep_alive, 0); 1098 INIT_LIST_HEAD(&ssi->txqueue); 1099 INIT_LIST_HEAD(&ssi->cmdqueue); 1100 atomic_set(&ssi->tx_usecnt, 0); 1101 hsi_client_set_drvdata(cl, ssi); 1102 ssi->cl = cl; 1103 INIT_WORK(&ssi->work, ssip_xmit_work); 1104 1105 ssi->channel_id_cmd = hsi_get_channel_id_by_name(cl, "mcsaab-control"); 1106 if (ssi->channel_id_cmd < 0) { 1107 err = ssi->channel_id_cmd; 1108 dev_err(dev, "Could not get cmd channel (%d)\n", err); 1109 goto out; 1110 } 1111 1112 ssi->channel_id_data = hsi_get_channel_id_by_name(cl, "mcsaab-data"); 1113 if (ssi->channel_id_data < 0) { 1114 err = ssi->channel_id_data; 1115 dev_err(dev, "Could not get data channel (%d)\n", err); 1116 goto out; 1117 } 1118 1119 err = ssip_alloc_cmds(ssi); 1120 if (err < 0) { 1121 dev_err(dev, "No memory for commands\n"); 1122 goto out; 1123 } 1124 1125 ssi->netdev = alloc_netdev(0, ifname, NET_NAME_UNKNOWN, ssip_pn_setup); 1126 if (!ssi->netdev) { 1127 dev_err(dev, "No memory for netdev\n"); 1128 err = -ENOMEM; 1129 goto out1; 1130 } 1131 1132 /* MTU range: 6 - 65535 */ 1133 ssi->netdev->min_mtu = PHONET_MIN_MTU; 1134 ssi->netdev->max_mtu = SSIP_MAX_MTU; 1135 1136 SET_NETDEV_DEV(ssi->netdev, dev); 1137 netif_carrier_off(ssi->netdev); 1138 err = register_netdev(ssi->netdev); 1139 if (err < 0) { 1140 dev_err(dev, "Register netdev failed (%d)\n", err); 1141 goto out2; 1142 } 1143 1144 list_add(&ssi->link, &ssip_list); 1145 1146 dev_dbg(dev, "channel configuration: cmd=%d, data=%d\n", 1147 ssi->channel_id_cmd, ssi->channel_id_data); 1148 1149 return 0; 1150 out2: 1151 free_netdev(ssi->netdev); 1152 out1: 1153 ssip_free_cmds(ssi); 1154 out: 1155 kfree(ssi); 1156 1157 return err; 1158 } 1159 1160 static int ssi_protocol_remove(struct device *dev) 1161 { 1162 struct hsi_client *cl = to_hsi_client(dev); 1163 struct ssi_protocol *ssi = hsi_client_drvdata(cl); 1164 1165 list_del(&ssi->link); 1166 unregister_netdev(ssi->netdev); 1167 ssip_free_cmds(ssi); 1168 hsi_client_set_drvdata(cl, NULL); 1169 kfree(ssi); 1170 1171 return 0; 1172 } 1173 1174 static struct hsi_client_driver ssip_driver = { 1175 .driver = { 1176 .name = "ssi-protocol", 1177 .owner = THIS_MODULE, 1178 .probe = ssi_protocol_probe, 1179 .remove = ssi_protocol_remove, 1180 }, 1181 }; 1182 1183 static int __init ssip_init(void) 1184 { 1185 pr_info("SSI protocol aka McSAAB added\n"); 1186 1187 return hsi_register_client_driver(&ssip_driver); 1188 } 1189 module_init(ssip_init); 1190 1191 static void __exit ssip_exit(void) 1192 { 1193 hsi_unregister_client_driver(&ssip_driver); 1194 pr_info("SSI protocol driver removed\n"); 1195 } 1196 module_exit(ssip_exit); 1197 1198 MODULE_ALIAS("hsi:ssi-protocol"); 1199 MODULE_AUTHOR("Carlos Chinea <carlos.chinea@nokia.com>"); 1200 MODULE_AUTHOR("Remi Denis-Courmont <remi.denis-courmont@nokia.com>"); 1201 MODULE_DESCRIPTION("SSI protocol improved aka McSAAB"); 1202 MODULE_LICENSE("GPL"); 1203