* Copyright 2010-2017 Intel Corporation.
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License, version 2,
* as published by the Free Software Foundation.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
* Disclaimer: The codes contained in these modules may be specific to
* the Intel Software Development Platform codenamed Knights Ferry,
* and the Intel product codenamed Knights Corner, and are not backward
* compatible with other Intel products. Additionally, Intel will NOT
* support the codes or instruction set in future products.
* Intel offers no warranty of any kind regarding the code. This code is
* licensed on an "AS IS" basis and Intel is not obligated to provide
* any support, assistance, installation, training, or other services
* of any kind. Intel is also not obligated to provide any updates,
* enhancements or extensions. Intel specifically disclaims any warranty
* of merchantability, non-infringement, fitness for any particular
* purpose, and any other warranty.
* Further, Intel disclaims all liability of any kind, including but
* not limited to liability for infringement of any proprietary rights,
* relating to the use of the code, even if Intel is notified of the
* possibility of such liability. Except as expressly stated in an Intel
* license agreement provided with this code and agreed upon with Intel,
* no license, express or implied, by estoppel or otherwise, to any
* intellectual property rights is granted herein.
#include <linux/module.h>
#include <linux/hardirq.h>
#include <linux/capability.h>
#include <linux/string.h>
#include <linux/vmalloc.h>
#include <linux/kernel.h>
#include <linux/mm_types.h>
#include <linux/jiffies.h>
#include <linux/irqflags.h>
#include <linux/spinlock.h>
#include <linux/semaphore.h>
#include <linux/kthread.h>
#include <linux/device.h>
#include <linux/workqueue.h>
#include <linux/interrupt.h>
#include <linux/netdevice.h>
#include <linux/debugfs.h>
#define ACPT_NACK_VERSION 3
#define ACPT_REQUEST_TIME 4
static struct class *class;
static struct device
*mbdev
;
static int host_notified
;
static struct timespec tod
;
show_timesync(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
return snprintf(buf
, PAGE_SIZE
, "Time: %s\n", timeset
? "set" : "not set");
set_synctime(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
struct scif_portID port
= {0, MIC_NOTIFY
};
int proto
= ACPT_REQUEST_TIME
;
int version
= ACPT_VERSION
;
if ((err
= scif_connect(epd
, &port
))) {
printk("MPSSBOOT error, synctime connect failed: %d\n", err
);
if ((err
= scif_send(epd
, &version
, sizeof(version
), 0)) != sizeof(version
)) {
printk("MPSSBOOT send version failed: %d\n", err
);
if ((err
= scif_send(epd
, &proto
, sizeof(proto
), 0)) != sizeof(proto
)) {
printk("MPSSBOOT send boot finished failed: %d\n", err
);
if ((err
= scif_recv(epd
, &proto
, sizeof(proto
), SCIF_RECV_BLOCK
)) != sizeof(proto
)) {
printk("MPSSBOOT protocol recv ack failed: %d\n", err
);
if (proto
!= ACPT_TIME_DATA
) {
printk("MPSSBOOT failed to receive time data packet %d\n", proto
);
if ((err
= scif_recv(epd
, &tod
, sizeof(tod
), SCIF_RECV_BLOCK
)) != sizeof(tod
)) {
printk("MPSSBOOT time data read size failed: %d\n", err
);
printk("MPSSBOOT Time of day sycned with host\n");
static DEVICE_ATTR(synctime
, S_IRUGO
| S_IWUSR
, show_timesync
, set_synctime
);
show_host_notified(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
return snprintf(buf
, PAGE_SIZE
, "%d\n", host_notified
);
set_host_notified(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
struct scif_portID port
= {0, MIC_NOTIFY
};
int version
= ACPT_VERSION
;
if ((err
= scif_connect(epd
, &port
))) {
printk("MPSSBOOT error, notify connect failed: %d\n", err
);
if ((err
= scif_send(epd
, &version
, sizeof(version
), 0)) != sizeof(version
)) {
printk("MPSSBOOT send version failed: %d\n", err
);
if ((err
= scif_send(epd
, &proto
, sizeof(proto
), 0)) != sizeof(proto
)) {
printk("MPSSBOOT send boot finished failed: %d\n", err
);
if ((err
= scif_recv(epd
, &proto
, sizeof(proto
), SCIF_RECV_BLOCK
)) != sizeof(proto
)) {
printk("MPSSBOOT protocol recv ack failed: %d\n", err
);
if (proto
!= ACPT_BOOT_ACK
)
printk("MPSSBOOT failed to receive boot ACK, got %d\n", proto
);
printk("MPSSBOOT Boot acknowledged\n");
static DEVICE_ATTR(host_notified
, S_IRUGO
| S_IWUSR
, show_host_notified
, set_host_notified
);
static struct attribute
*mb_attributes
[] = {
&dev_attr_host_notified
.attr
,
struct attribute_group mb_attr_group
= {
/* This function closes the endpoint established on init */
sysfs_remove_group(&mbdev
->kobj
, &mb_attr_group
);
device_destroy(class, dev
);
mpssboot_devnode(struct device
*dev
, mode_t
*mode
)
return kasprintf(GFP_KERNEL
, "%s", dev_name(dev
));
/* This function initializes a SCIF connection to the host */
//static struct device dev;
alloc_chrdev_region(&dev
, 0, 2, "micnotify");
class = class_create(THIS_MODULE
, "micnotify");
class->devnode
= mpssboot_devnode
;
mbdev
= device_create(class, NULL
, dev
, NULL
, "notify");
result
= sysfs_create_group(&mbdev
->kobj
, &mb_attr_group
);
module_init(mpssboot_init
);
module_exit(mpssboot_exit
);