aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/char
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/char')
-rw-r--r--drivers/char/agp/generic.c4
-rw-r--r--drivers/char/agp/intel-agp.c3
-rw-r--r--drivers/char/hpet.c2
-rw-r--r--drivers/char/hw_random/virtio-rng.c4
-rw-r--r--drivers/char/ipmi/ipmi_msghandler.c211
-rw-r--r--drivers/char/ipmi/ipmi_si_intf.c150
-rw-r--r--drivers/char/mem.c27
-rw-r--r--drivers/char/sysrq.c1
-rw-r--r--drivers/char/vt.c2
9 files changed, 313 insertions, 91 deletions
diff --git a/drivers/char/agp/generic.c b/drivers/char/agp/generic.c
index 10d6cbd7c05e..2224b762b7fb 100644
--- a/drivers/char/agp/generic.c
+++ b/drivers/char/agp/generic.c
@@ -1226,7 +1226,7 @@ int agp_generic_alloc_pages(struct agp_bridge_data *bridge, struct agp_memory *m
1226 int i, ret = -ENOMEM; 1226 int i, ret = -ENOMEM;
1227 1227
1228 for (i = 0; i < num_pages; i++) { 1228 for (i = 0; i < num_pages; i++) {
1229 page = alloc_page(GFP_KERNEL | GFP_DMA32); 1229 page = alloc_page(GFP_KERNEL | GFP_DMA32 | __GFP_ZERO);
1230 /* agp_free_memory() needs gart address */ 1230 /* agp_free_memory() needs gart address */
1231 if (page == NULL) 1231 if (page == NULL)
1232 goto out; 1232 goto out;
@@ -1257,7 +1257,7 @@ void *agp_generic_alloc_page(struct agp_bridge_data *bridge)
1257{ 1257{
1258 struct page * page; 1258 struct page * page;
1259 1259
1260 page = alloc_page(GFP_KERNEL | GFP_DMA32); 1260 page = alloc_page(GFP_KERNEL | GFP_DMA32 | __GFP_ZERO);
1261 if (page == NULL) 1261 if (page == NULL)
1262 return NULL; 1262 return NULL;
1263 1263
diff --git a/drivers/char/agp/intel-agp.c b/drivers/char/agp/intel-agp.c
index 9d9490e22e07..3686912427ba 100644
--- a/drivers/char/agp/intel-agp.c
+++ b/drivers/char/agp/intel-agp.c
@@ -2131,6 +2131,8 @@ static const struct intel_driver_description {
2131 { PCI_DEVICE_ID_INTEL_82845G_HB, PCI_DEVICE_ID_INTEL_82845G_IG, 0, "830M", 2131 { PCI_DEVICE_ID_INTEL_82845G_HB, PCI_DEVICE_ID_INTEL_82845G_IG, 0, "830M",
2132 &intel_845_driver, &intel_830_driver }, 2132 &intel_845_driver, &intel_830_driver },
2133 { PCI_DEVICE_ID_INTEL_82850_HB, 0, 0, "i850", &intel_850_driver, NULL }, 2133 { PCI_DEVICE_ID_INTEL_82850_HB, 0, 0, "i850", &intel_850_driver, NULL },
2134 { PCI_DEVICE_ID_INTEL_82854_HB, PCI_DEVICE_ID_INTEL_82854_IG, 0, "854",
2135 &intel_845_driver, &intel_830_driver },
2134 { PCI_DEVICE_ID_INTEL_82855PM_HB, 0, 0, "855PM", &intel_845_driver, NULL }, 2136 { PCI_DEVICE_ID_INTEL_82855PM_HB, 0, 0, "855PM", &intel_845_driver, NULL },
2135 { PCI_DEVICE_ID_INTEL_82855GM_HB, PCI_DEVICE_ID_INTEL_82855GM_IG, 0, "855GM", 2137 { PCI_DEVICE_ID_INTEL_82855GM_HB, PCI_DEVICE_ID_INTEL_82855GM_IG, 0, "855GM",
2136 &intel_845_driver, &intel_830_driver }, 2138 &intel_845_driver, &intel_830_driver },
@@ -2355,6 +2357,7 @@ static struct pci_device_id agp_intel_pci_table[] = {
2355 ID(PCI_DEVICE_ID_INTEL_82845_HB), 2357 ID(PCI_DEVICE_ID_INTEL_82845_HB),
2356 ID(PCI_DEVICE_ID_INTEL_82845G_HB), 2358 ID(PCI_DEVICE_ID_INTEL_82845G_HB),
2357 ID(PCI_DEVICE_ID_INTEL_82850_HB), 2359 ID(PCI_DEVICE_ID_INTEL_82850_HB),
2360 ID(PCI_DEVICE_ID_INTEL_82854_HB),
2358 ID(PCI_DEVICE_ID_INTEL_82855PM_HB), 2361 ID(PCI_DEVICE_ID_INTEL_82855PM_HB),
2359 ID(PCI_DEVICE_ID_INTEL_82855GM_HB), 2362 ID(PCI_DEVICE_ID_INTEL_82855GM_HB),
2360 ID(PCI_DEVICE_ID_INTEL_82860_HB), 2363 ID(PCI_DEVICE_ID_INTEL_82860_HB),
diff --git a/drivers/char/hpet.c b/drivers/char/hpet.c
index 50dfa3bc71ce..340ba4f9dc54 100644
--- a/drivers/char/hpet.c
+++ b/drivers/char/hpet.c
@@ -72,7 +72,7 @@ static u32 hpet_nhpet, hpet_max_freq = HPET_USER_FREQ;
72#ifdef CONFIG_IA64 72#ifdef CONFIG_IA64
73static void __iomem *hpet_mctr; 73static void __iomem *hpet_mctr;
74 74
75static cycle_t read_hpet(void) 75static cycle_t read_hpet(struct clocksource *cs)
76{ 76{
77 return (cycle_t)read_counter((void __iomem *)hpet_mctr); 77 return (cycle_t)read_counter((void __iomem *)hpet_mctr);
78} 78}
diff --git a/drivers/char/hw_random/virtio-rng.c b/drivers/char/hw_random/virtio-rng.c
index d0e563e4fc39..86e83f883139 100644
--- a/drivers/char/hw_random/virtio-rng.c
+++ b/drivers/char/hw_random/virtio-rng.c
@@ -37,9 +37,9 @@ static void random_recv_done(struct virtqueue *vq)
37{ 37{
38 int len; 38 int len;
39 39
40 /* We never get spurious callbacks. */ 40 /* We can get spurious callbacks, e.g. shared IRQs + virtio_pci. */
41 if (!vq->vq_ops->get_buf(vq, &len)) 41 if (!vq->vq_ops->get_buf(vq, &len))
42 BUG(); 42 return;
43 43
44 data_left = len / sizeof(random_data[0]); 44 data_left = len / sizeof(random_data[0]);
45 complete(&have_data); 45 complete(&have_data);
diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c
index e93fc8d22fb2..aa83a0865ec1 100644
--- a/drivers/char/ipmi/ipmi_msghandler.c
+++ b/drivers/char/ipmi/ipmi_msghandler.c
@@ -285,6 +285,11 @@ enum ipmi_stat_indexes {
285 /* Events that were received with the proper format. */ 285 /* Events that were received with the proper format. */
286 IPMI_STAT_events, 286 IPMI_STAT_events,
287 287
288 /* Retransmissions on IPMB that failed. */
289 IPMI_STAT_dropped_rexmit_ipmb_commands,
290
291 /* Retransmissions on LAN that failed. */
292 IPMI_STAT_dropped_rexmit_lan_commands,
288 293
289 /* This *must* remain last, add new values above this. */ 294 /* This *must* remain last, add new values above this. */
290 IPMI_NUM_STATS 295 IPMI_NUM_STATS
@@ -445,6 +450,20 @@ static DEFINE_MUTEX(smi_watchers_mutex);
445#define ipmi_get_stat(intf, stat) \ 450#define ipmi_get_stat(intf, stat) \
446 ((unsigned int) atomic_read(&(intf)->stats[IPMI_STAT_ ## stat])) 451 ((unsigned int) atomic_read(&(intf)->stats[IPMI_STAT_ ## stat]))
447 452
453static int is_lan_addr(struct ipmi_addr *addr)
454{
455 return addr->addr_type == IPMI_LAN_ADDR_TYPE;
456}
457
458static int is_ipmb_addr(struct ipmi_addr *addr)
459{
460 return addr->addr_type == IPMI_IPMB_ADDR_TYPE;
461}
462
463static int is_ipmb_bcast_addr(struct ipmi_addr *addr)
464{
465 return addr->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE;
466}
448 467
449static void free_recv_msg_list(struct list_head *q) 468static void free_recv_msg_list(struct list_head *q)
450{ 469{
@@ -601,8 +620,7 @@ ipmi_addr_equal(struct ipmi_addr *addr1, struct ipmi_addr *addr2)
601 return (smi_addr1->lun == smi_addr2->lun); 620 return (smi_addr1->lun == smi_addr2->lun);
602 } 621 }
603 622
604 if ((addr1->addr_type == IPMI_IPMB_ADDR_TYPE) 623 if (is_ipmb_addr(addr1) || is_ipmb_bcast_addr(addr1)) {
605 || (addr1->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE)) {
606 struct ipmi_ipmb_addr *ipmb_addr1 624 struct ipmi_ipmb_addr *ipmb_addr1
607 = (struct ipmi_ipmb_addr *) addr1; 625 = (struct ipmi_ipmb_addr *) addr1;
608 struct ipmi_ipmb_addr *ipmb_addr2 626 struct ipmi_ipmb_addr *ipmb_addr2
@@ -612,7 +630,7 @@ ipmi_addr_equal(struct ipmi_addr *addr1, struct ipmi_addr *addr2)
612 && (ipmb_addr1->lun == ipmb_addr2->lun)); 630 && (ipmb_addr1->lun == ipmb_addr2->lun));
613 } 631 }
614 632
615 if (addr1->addr_type == IPMI_LAN_ADDR_TYPE) { 633 if (is_lan_addr(addr1)) {
616 struct ipmi_lan_addr *lan_addr1 634 struct ipmi_lan_addr *lan_addr1
617 = (struct ipmi_lan_addr *) addr1; 635 = (struct ipmi_lan_addr *) addr1;
618 struct ipmi_lan_addr *lan_addr2 636 struct ipmi_lan_addr *lan_addr2
@@ -644,14 +662,13 @@ int ipmi_validate_addr(struct ipmi_addr *addr, int len)
644 || (addr->channel < 0)) 662 || (addr->channel < 0))
645 return -EINVAL; 663 return -EINVAL;
646 664
647 if ((addr->addr_type == IPMI_IPMB_ADDR_TYPE) 665 if (is_ipmb_addr(addr) || is_ipmb_bcast_addr(addr)) {
648 || (addr->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE)) {
649 if (len < sizeof(struct ipmi_ipmb_addr)) 666 if (len < sizeof(struct ipmi_ipmb_addr))
650 return -EINVAL; 667 return -EINVAL;
651 return 0; 668 return 0;
652 } 669 }
653 670
654 if (addr->addr_type == IPMI_LAN_ADDR_TYPE) { 671 if (is_lan_addr(addr)) {
655 if (len < sizeof(struct ipmi_lan_addr)) 672 if (len < sizeof(struct ipmi_lan_addr))
656 return -EINVAL; 673 return -EINVAL;
657 return 0; 674 return 0;
@@ -1503,8 +1520,7 @@ static int i_ipmi_request(ipmi_user_t user,
1503 memcpy(&(smi_msg->data[2]), msg->data, msg->data_len); 1520 memcpy(&(smi_msg->data[2]), msg->data, msg->data_len);
1504 smi_msg->data_size = msg->data_len + 2; 1521 smi_msg->data_size = msg->data_len + 2;
1505 ipmi_inc_stat(intf, sent_local_commands); 1522 ipmi_inc_stat(intf, sent_local_commands);
1506 } else if ((addr->addr_type == IPMI_IPMB_ADDR_TYPE) 1523 } else if (is_ipmb_addr(addr) || is_ipmb_bcast_addr(addr)) {
1507 || (addr->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE)) {
1508 struct ipmi_ipmb_addr *ipmb_addr; 1524 struct ipmi_ipmb_addr *ipmb_addr;
1509 unsigned char ipmb_seq; 1525 unsigned char ipmb_seq;
1510 long seqid; 1526 long seqid;
@@ -1583,8 +1599,6 @@ static int i_ipmi_request(ipmi_user_t user,
1583 1599
1584 spin_lock_irqsave(&(intf->seq_lock), flags); 1600 spin_lock_irqsave(&(intf->seq_lock), flags);
1585 1601
1586 ipmi_inc_stat(intf, sent_ipmb_commands);
1587
1588 /* 1602 /*
1589 * Create a sequence number with a 1 second 1603 * Create a sequence number with a 1 second
1590 * timeout and 4 retries. 1604 * timeout and 4 retries.
@@ -1606,6 +1620,8 @@ static int i_ipmi_request(ipmi_user_t user,
1606 goto out_err; 1620 goto out_err;
1607 } 1621 }
1608 1622
1623 ipmi_inc_stat(intf, sent_ipmb_commands);
1624
1609 /* 1625 /*
1610 * Store the sequence number in the message, 1626 * Store the sequence number in the message,
1611 * so that when the send message response 1627 * so that when the send message response
@@ -1635,7 +1651,7 @@ static int i_ipmi_request(ipmi_user_t user,
1635 */ 1651 */
1636 spin_unlock_irqrestore(&(intf->seq_lock), flags); 1652 spin_unlock_irqrestore(&(intf->seq_lock), flags);
1637 } 1653 }
1638 } else if (addr->addr_type == IPMI_LAN_ADDR_TYPE) { 1654 } else if (is_lan_addr(addr)) {
1639 struct ipmi_lan_addr *lan_addr; 1655 struct ipmi_lan_addr *lan_addr;
1640 unsigned char ipmb_seq; 1656 unsigned char ipmb_seq;
1641 long seqid; 1657 long seqid;
@@ -1696,8 +1712,6 @@ static int i_ipmi_request(ipmi_user_t user,
1696 1712
1697 spin_lock_irqsave(&(intf->seq_lock), flags); 1713 spin_lock_irqsave(&(intf->seq_lock), flags);
1698 1714
1699 ipmi_inc_stat(intf, sent_lan_commands);
1700
1701 /* 1715 /*
1702 * Create a sequence number with a 1 second 1716 * Create a sequence number with a 1 second
1703 * timeout and 4 retries. 1717 * timeout and 4 retries.
@@ -1719,6 +1733,8 @@ static int i_ipmi_request(ipmi_user_t user,
1719 goto out_err; 1733 goto out_err;
1720 } 1734 }
1721 1735
1736 ipmi_inc_stat(intf, sent_lan_commands);
1737
1722 /* 1738 /*
1723 * Store the sequence number in the message, 1739 * Store the sequence number in the message,
1724 * so that when the send message response 1740 * so that when the send message response
@@ -1937,6 +1953,10 @@ static int stat_file_read_proc(char *page, char **start, off_t off,
1937 ipmi_get_stat(intf, invalid_events)); 1953 ipmi_get_stat(intf, invalid_events));
1938 out += sprintf(out, "events: %u\n", 1954 out += sprintf(out, "events: %u\n",
1939 ipmi_get_stat(intf, events)); 1955 ipmi_get_stat(intf, events));
1956 out += sprintf(out, "failed rexmit LAN msgs: %u\n",
1957 ipmi_get_stat(intf, dropped_rexmit_lan_commands));
1958 out += sprintf(out, "failed rexmit IPMB msgs: %u\n",
1959 ipmi_get_stat(intf, dropped_rexmit_ipmb_commands));
1940 1960
1941 return (out - ((char *) page)); 1961 return (out - ((char *) page));
1942} 1962}
@@ -3264,6 +3284,114 @@ static int handle_lan_get_msg_cmd(ipmi_smi_t intf,
3264 return rv; 3284 return rv;
3265} 3285}
3266 3286
3287/*
3288 * This routine will handle "Get Message" command responses with
3289 * channels that use an OEM Medium. The message format belongs to
3290 * the OEM. See IPMI 2.0 specification, Chapter 6 and
3291 * Chapter 22, sections 22.6 and 22.24 for more details.
3292 */
3293static int handle_oem_get_msg_cmd(ipmi_smi_t intf,
3294 struct ipmi_smi_msg *msg)
3295{
3296 struct cmd_rcvr *rcvr;
3297 int rv = 0;
3298 unsigned char netfn;
3299 unsigned char cmd;
3300 unsigned char chan;
3301 ipmi_user_t user = NULL;
3302 struct ipmi_system_interface_addr *smi_addr;
3303 struct ipmi_recv_msg *recv_msg;
3304
3305 /*
3306 * We expect the OEM SW to perform error checking
3307 * so we just do some basic sanity checks
3308 */
3309 if (msg->rsp_size < 4) {
3310 /* Message not big enough, just ignore it. */
3311 ipmi_inc_stat(intf, invalid_commands);
3312 return 0;
3313 }
3314
3315 if (msg->rsp[2] != 0) {
3316 /* An error getting the response, just ignore it. */
3317 return 0;
3318 }
3319
3320 /*
3321 * This is an OEM Message so the OEM needs to know how
3322 * handle the message. We do no interpretation.
3323 */
3324 netfn = msg->rsp[0] >> 2;
3325 cmd = msg->rsp[1];
3326 chan = msg->rsp[3] & 0xf;
3327
3328 rcu_read_lock();
3329 rcvr = find_cmd_rcvr(intf, netfn, cmd, chan);
3330 if (rcvr) {
3331 user = rcvr->user;
3332 kref_get(&user->refcount);
3333 } else
3334 user = NULL;
3335 rcu_read_unlock();
3336
3337 if (user == NULL) {
3338 /* We didn't find a user, just give up. */
3339 ipmi_inc_stat(intf, unhandled_commands);
3340
3341 /*
3342 * Don't do anything with these messages, just allow
3343 * them to be freed.
3344 */
3345
3346 rv = 0;
3347 } else {
3348 /* Deliver the message to the user. */
3349 ipmi_inc_stat(intf, handled_commands);
3350
3351 recv_msg = ipmi_alloc_recv_msg();
3352 if (!recv_msg) {
3353 /*
3354 * We couldn't allocate memory for the
3355 * message, so requeue it for handling
3356 * later.
3357 */
3358 rv = 1;
3359 kref_put(&user->refcount, free_user);
3360 } else {
3361 /*
3362 * OEM Messages are expected to be delivered via
3363 * the system interface to SMS software. We might
3364 * need to visit this again depending on OEM
3365 * requirements
3366 */
3367 smi_addr = ((struct ipmi_system_interface_addr *)
3368 &(recv_msg->addr));
3369 smi_addr->addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
3370 smi_addr->channel = IPMI_BMC_CHANNEL;
3371 smi_addr->lun = msg->rsp[0] & 3;
3372
3373 recv_msg->user = user;
3374 recv_msg->user_msg_data = NULL;
3375 recv_msg->recv_type = IPMI_OEM_RECV_TYPE;
3376 recv_msg->msg.netfn = msg->rsp[0] >> 2;
3377 recv_msg->msg.cmd = msg->rsp[1];
3378 recv_msg->msg.data = recv_msg->msg_data;
3379
3380 /*
3381 * The message starts at byte 4 which follows the
3382 * the Channel Byte in the "GET MESSAGE" command
3383 */
3384 recv_msg->msg.data_len = msg->rsp_size - 4;
3385 memcpy(recv_msg->msg_data,
3386 &(msg->rsp[4]),
3387 msg->rsp_size - 4);
3388 deliver_response(recv_msg);
3389 }
3390 }
3391
3392 return rv;
3393}
3394
3267static void copy_event_into_recv_msg(struct ipmi_recv_msg *recv_msg, 3395static void copy_event_into_recv_msg(struct ipmi_recv_msg *recv_msg,
3268 struct ipmi_smi_msg *msg) 3396 struct ipmi_smi_msg *msg)
3269{ 3397{
@@ -3519,6 +3647,17 @@ static int handle_new_recv_msg(ipmi_smi_t intf,
3519 goto out; 3647 goto out;
3520 } 3648 }
3521 3649
3650 /*
3651 ** We need to make sure the channels have been initialized.
3652 ** The channel_handler routine will set the "curr_channel"
3653 ** equal to or greater than IPMI_MAX_CHANNELS when all the
3654 ** channels for this interface have been initialized.
3655 */
3656 if (intf->curr_channel < IPMI_MAX_CHANNELS) {
3657 requeue = 1; /* Just put the message back for now */
3658 goto out;
3659 }
3660
3522 switch (intf->channels[chan].medium) { 3661 switch (intf->channels[chan].medium) {
3523 case IPMI_CHANNEL_MEDIUM_IPMB: 3662 case IPMI_CHANNEL_MEDIUM_IPMB:
3524 if (msg->rsp[4] & 0x04) { 3663 if (msg->rsp[4] & 0x04) {
@@ -3554,11 +3693,20 @@ static int handle_new_recv_msg(ipmi_smi_t intf,
3554 break; 3693 break;
3555 3694
3556 default: 3695 default:
3557 /* 3696 /* Check for OEM Channels. Clients had better
3558 * We don't handle the channel type, so just 3697 register for these commands. */
3559 * free the message. 3698 if ((intf->channels[chan].medium
3560 */ 3699 >= IPMI_CHANNEL_MEDIUM_OEM_MIN)
3561 requeue = 0; 3700 && (intf->channels[chan].medium
3701 <= IPMI_CHANNEL_MEDIUM_OEM_MAX)) {
3702 requeue = handle_oem_get_msg_cmd(intf, msg);
3703 } else {
3704 /*
3705 * We don't handle the channel type, so just
3706 * free the message.
3707 */
3708 requeue = 0;
3709 }
3562 } 3710 }
3563 3711
3564 } else if ((msg->rsp[0] == ((IPMI_NETFN_APP_REQUEST|1) << 2)) 3712 } else if ((msg->rsp[0] == ((IPMI_NETFN_APP_REQUEST|1) << 2))
@@ -3730,7 +3878,7 @@ static void check_msg_timeout(ipmi_smi_t intf, struct seq_table *ent,
3730 list_add_tail(&msg->link, timeouts); 3878 list_add_tail(&msg->link, timeouts);
3731 if (ent->broadcast) 3879 if (ent->broadcast)
3732 ipmi_inc_stat(intf, timed_out_ipmb_broadcasts); 3880 ipmi_inc_stat(intf, timed_out_ipmb_broadcasts);
3733 else if (ent->recv_msg->addr.addr_type == IPMI_LAN_ADDR_TYPE) 3881 else if (is_lan_addr(&ent->recv_msg->addr))
3734 ipmi_inc_stat(intf, timed_out_lan_commands); 3882 ipmi_inc_stat(intf, timed_out_lan_commands);
3735 else 3883 else
3736 ipmi_inc_stat(intf, timed_out_ipmb_commands); 3884 ipmi_inc_stat(intf, timed_out_ipmb_commands);
@@ -3744,15 +3892,17 @@ static void check_msg_timeout(ipmi_smi_t intf, struct seq_table *ent,
3744 */ 3892 */
3745 ent->timeout = MAX_MSG_TIMEOUT; 3893 ent->timeout = MAX_MSG_TIMEOUT;
3746 ent->retries_left--; 3894 ent->retries_left--;
3747 if (ent->recv_msg->addr.addr_type == IPMI_LAN_ADDR_TYPE)
3748 ipmi_inc_stat(intf, retransmitted_lan_commands);
3749 else
3750 ipmi_inc_stat(intf, retransmitted_ipmb_commands);
3751
3752 smi_msg = smi_from_recv_msg(intf, ent->recv_msg, slot, 3895 smi_msg = smi_from_recv_msg(intf, ent->recv_msg, slot,
3753 ent->seqid); 3896 ent->seqid);
3754 if (!smi_msg) 3897 if (!smi_msg) {
3898 if (is_lan_addr(&ent->recv_msg->addr))
3899 ipmi_inc_stat(intf,
3900 dropped_rexmit_lan_commands);
3901 else
3902 ipmi_inc_stat(intf,
3903 dropped_rexmit_ipmb_commands);
3755 return; 3904 return;
3905 }
3756 3906
3757 spin_unlock_irqrestore(&intf->seq_lock, *flags); 3907 spin_unlock_irqrestore(&intf->seq_lock, *flags);
3758 3908
@@ -3764,10 +3914,17 @@ static void check_msg_timeout(ipmi_smi_t intf, struct seq_table *ent,
3764 * resent. 3914 * resent.
3765 */ 3915 */
3766 handlers = intf->handlers; 3916 handlers = intf->handlers;
3767 if (handlers) 3917 if (handlers) {
3918 if (is_lan_addr(&ent->recv_msg->addr))
3919 ipmi_inc_stat(intf,
3920 retransmitted_lan_commands);
3921 else
3922 ipmi_inc_stat(intf,
3923 retransmitted_ipmb_commands);
3924
3768 intf->handlers->sender(intf->send_info, 3925 intf->handlers->sender(intf->send_info,
3769 smi_msg, 0); 3926 smi_msg, 0);
3770 else 3927 } else
3771 ipmi_free_smi_msg(smi_msg); 3928 ipmi_free_smi_msg(smi_msg);
3772 3929
3773 spin_lock_irqsave(&intf->seq_lock, *flags); 3930 spin_lock_irqsave(&intf->seq_lock, *flags);
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index e58ea4cd55ce..259644646b82 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -82,12 +82,6 @@
82#define SI_SHORT_TIMEOUT_USEC 250 /* .25ms when the SM request a 82#define SI_SHORT_TIMEOUT_USEC 250 /* .25ms when the SM request a
83 short timeout */ 83 short timeout */
84 84
85/* Bit for BMC global enables. */
86#define IPMI_BMC_RCV_MSG_INTR 0x01
87#define IPMI_BMC_EVT_MSG_INTR 0x02
88#define IPMI_BMC_EVT_MSG_BUFF 0x04
89#define IPMI_BMC_SYS_LOG 0x08
90
91enum si_intf_state { 85enum si_intf_state {
92 SI_NORMAL, 86 SI_NORMAL,
93 SI_GETTING_FLAGS, 87 SI_GETTING_FLAGS,
@@ -220,6 +214,9 @@ struct smi_info {
220 OEM2_DATA_AVAIL) 214 OEM2_DATA_AVAIL)
221 unsigned char msg_flags; 215 unsigned char msg_flags;
222 216
217 /* Does the BMC have an event buffer? */
218 char has_event_buffer;
219
223 /* 220 /*
224 * If set to true, this will request events the next time the 221 * If set to true, this will request events the next time the
225 * state machine is idle. 222 * state machine is idle.
@@ -968,7 +965,8 @@ static void request_events(void *send_info)
968{ 965{
969 struct smi_info *smi_info = send_info; 966 struct smi_info *smi_info = send_info;
970 967
971 if (atomic_read(&smi_info->stop_operation)) 968 if (atomic_read(&smi_info->stop_operation) ||
969 !smi_info->has_event_buffer)
972 return; 970 return;
973 971
974 atomic_set(&smi_info->req_events, 1); 972 atomic_set(&smi_info->req_events, 1);
@@ -2407,26 +2405,9 @@ static struct of_platform_driver ipmi_of_platform_driver = {
2407}; 2405};
2408#endif /* CONFIG_PPC_OF */ 2406#endif /* CONFIG_PPC_OF */
2409 2407
2410 2408static int wait_for_msg_done(struct smi_info *smi_info)
2411static int try_get_dev_id(struct smi_info *smi_info)
2412{ 2409{
2413 unsigned char msg[2];
2414 unsigned char *resp;
2415 unsigned long resp_len;
2416 enum si_sm_result smi_result; 2410 enum si_sm_result smi_result;
2417 int rv = 0;
2418
2419 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
2420 if (!resp)
2421 return -ENOMEM;
2422
2423 /*
2424 * Do a Get Device ID command, since it comes back with some
2425 * useful info.
2426 */
2427 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
2428 msg[1] = IPMI_GET_DEVICE_ID_CMD;
2429 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
2430 2411
2431 smi_result = smi_info->handlers->event(smi_info->si_sm, 0); 2412 smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
2432 for (;;) { 2413 for (;;) {
@@ -2441,16 +2422,39 @@ static int try_get_dev_id(struct smi_info *smi_info)
2441 } else 2422 } else
2442 break; 2423 break;
2443 } 2424 }
2444 if (smi_result == SI_SM_HOSED) { 2425 if (smi_result == SI_SM_HOSED)
2445 /* 2426 /*
2446 * We couldn't get the state machine to run, so whatever's at 2427 * We couldn't get the state machine to run, so whatever's at
2447 * the port is probably not an IPMI SMI interface. 2428 * the port is probably not an IPMI SMI interface.
2448 */ 2429 */
2449 rv = -ENODEV; 2430 return -ENODEV;
2431
2432 return 0;
2433}
2434
2435static int try_get_dev_id(struct smi_info *smi_info)
2436{
2437 unsigned char msg[2];
2438 unsigned char *resp;
2439 unsigned long resp_len;
2440 int rv = 0;
2441
2442 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
2443 if (!resp)
2444 return -ENOMEM;
2445
2446 /*
2447 * Do a Get Device ID command, since it comes back with some
2448 * useful info.
2449 */
2450 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
2451 msg[1] = IPMI_GET_DEVICE_ID_CMD;
2452 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
2453
2454 rv = wait_for_msg_done(smi_info);
2455 if (rv)
2450 goto out; 2456 goto out;
2451 }
2452 2457
2453 /* Otherwise, we got some data. */
2454 resp_len = smi_info->handlers->get_result(smi_info->si_sm, 2458 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
2455 resp, IPMI_MAX_MSG_LENGTH); 2459 resp, IPMI_MAX_MSG_LENGTH);
2456 2460
@@ -2462,6 +2466,88 @@ static int try_get_dev_id(struct smi_info *smi_info)
2462 return rv; 2466 return rv;
2463} 2467}
2464 2468
2469static int try_enable_event_buffer(struct smi_info *smi_info)
2470{
2471 unsigned char msg[3];
2472 unsigned char *resp;
2473 unsigned long resp_len;
2474 int rv = 0;
2475
2476 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
2477 if (!resp)
2478 return -ENOMEM;
2479
2480 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
2481 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
2482 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
2483
2484 rv = wait_for_msg_done(smi_info);
2485 if (rv) {
2486 printk(KERN_WARNING
2487 "ipmi_si: Error getting response from get global,"
2488 " enables command, the event buffer is not"
2489 " enabled.\n");
2490 goto out;
2491 }
2492
2493 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
2494 resp, IPMI_MAX_MSG_LENGTH);
2495
2496 if (resp_len < 4 ||
2497 resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
2498 resp[1] != IPMI_GET_BMC_GLOBAL_ENABLES_CMD ||
2499 resp[2] != 0) {
2500 printk(KERN_WARNING
2501 "ipmi_si: Invalid return from get global"
2502 " enables command, cannot enable the event"
2503 " buffer.\n");
2504 rv = -EINVAL;
2505 goto out;
2506 }
2507
2508 if (resp[3] & IPMI_BMC_EVT_MSG_BUFF)
2509 /* buffer is already enabled, nothing to do. */
2510 goto out;
2511
2512 msg[0] = IPMI_NETFN_APP_REQUEST << 2;
2513 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
2514 msg[2] = resp[3] | IPMI_BMC_EVT_MSG_BUFF;
2515 smi_info->handlers->start_transaction(smi_info->si_sm, msg, 3);
2516
2517 rv = wait_for_msg_done(smi_info);
2518 if (rv) {
2519 printk(KERN_WARNING
2520 "ipmi_si: Error getting response from set global,"
2521 " enables command, the event buffer is not"
2522 " enabled.\n");
2523 goto out;
2524 }
2525
2526 resp_len = smi_info->handlers->get_result(smi_info->si_sm,
2527 resp, IPMI_MAX_MSG_LENGTH);
2528
2529 if (resp_len < 3 ||
2530 resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
2531 resp[1] != IPMI_SET_BMC_GLOBAL_ENABLES_CMD) {
2532 printk(KERN_WARNING
2533 "ipmi_si: Invalid return from get global,"
2534 "enables command, not enable the event"
2535 " buffer.\n");
2536 rv = -EINVAL;
2537 goto out;
2538 }
2539
2540 if (resp[2] != 0)
2541 /*
2542 * An error when setting the event buffer bit means
2543 * that the event buffer is not supported.
2544 */
2545 rv = -ENOENT;
2546 out:
2547 kfree(resp);
2548 return rv;
2549}
2550
2465static int type_file_read_proc(char *page, char **start, off_t off, 2551static int type_file_read_proc(char *page, char **start, off_t off,
2466 int count, int *eof, void *data) 2552 int count, int *eof, void *data)
2467{ 2553{
@@ -2847,6 +2933,10 @@ static int try_smi_init(struct smi_info *new_smi)
2847 new_smi->intf_num = smi_num; 2933 new_smi->intf_num = smi_num;
2848 smi_num++; 2934 smi_num++;
2849 2935
2936 rv = try_enable_event_buffer(new_smi);
2937 if (rv == 0)
2938 new_smi->has_event_buffer = 1;
2939
2850 /* 2940 /*
2851 * Start clearing the flags before we enable interrupts or the 2941 * Start clearing the flags before we enable interrupts or the
2852 * timer to avoid racing with the timer. 2942 * timer to avoid racing with the timer.
@@ -2863,7 +2953,7 @@ static int try_smi_init(struct smi_info *new_smi)
2863 */ 2953 */
2864 new_smi->pdev = platform_device_alloc("ipmi_si", 2954 new_smi->pdev = platform_device_alloc("ipmi_si",
2865 new_smi->intf_num); 2955 new_smi->intf_num);
2866 if (rv) { 2956 if (!new_smi->pdev) {
2867 printk(KERN_ERR 2957 printk(KERN_ERR
2868 "ipmi_si_intf:" 2958 "ipmi_si_intf:"
2869 " Unable to allocate platform device\n"); 2959 " Unable to allocate platform device\n");
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index 3586b3b3df3f..8f05c38c2f06 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -301,33 +301,7 @@ static inline int private_mapping_ok(struct vm_area_struct *vma)
301} 301}
302#endif 302#endif
303 303
304void __attribute__((weak))
305map_devmem(unsigned long pfn, unsigned long len, pgprot_t prot)
306{
307 /* nothing. architectures can override. */
308}
309
310void __attribute__((weak))
311unmap_devmem(unsigned long pfn, unsigned long len, pgprot_t prot)
312{
313 /* nothing. architectures can override. */
314}
315
316static void mmap_mem_open(struct vm_area_struct *vma)
317{
318 map_devmem(vma->vm_pgoff, vma->vm_end - vma->vm_start,
319 vma->vm_page_prot);
320}
321
322static void mmap_mem_close(struct vm_area_struct *vma)
323{
324 unmap_devmem(vma->vm_pgoff, vma->vm_end - vma->vm_start,
325 vma->vm_page_prot);
326}
327
328static struct vm_operations_struct mmap_mem_ops = { 304static struct vm_operations_struct mmap_mem_ops = {
329 .open = mmap_mem_open,
330 .close = mmap_mem_close,
331#ifdef CONFIG_HAVE_IOREMAP_PROT 305#ifdef CONFIG_HAVE_IOREMAP_PROT
332 .access = generic_access_phys 306 .access = generic_access_phys
333#endif 307#endif
@@ -362,7 +336,6 @@ static int mmap_mem(struct file * file, struct vm_area_struct * vma)
362 vma->vm_pgoff, 336 vma->vm_pgoff,
363 size, 337 size,
364 vma->vm_page_prot)) { 338 vma->vm_page_prot)) {
365 unmap_devmem(vma->vm_pgoff, size, vma->vm_page_prot);
366 return -EAGAIN; 339 return -EAGAIN;
367 } 340 }
368 return 0; 341 return 0;
diff --git a/drivers/char/sysrq.c b/drivers/char/sysrq.c
index 6de020d078e1..b0a6a3e51924 100644
--- a/drivers/char/sysrq.c
+++ b/drivers/char/sysrq.c
@@ -35,7 +35,6 @@
35#include <linux/vt_kern.h> 35#include <linux/vt_kern.h>
36#include <linux/workqueue.h> 36#include <linux/workqueue.h>
37#include <linux/kexec.h> 37#include <linux/kexec.h>
38#include <linux/interrupt.h>
39#include <linux/hrtimer.h> 38#include <linux/hrtimer.h>
40#include <linux/oom.h> 39#include <linux/oom.h>
41 40
diff --git a/drivers/char/vt.c b/drivers/char/vt.c
index 2c1d133819b5..08151d4de489 100644
--- a/drivers/char/vt.c
+++ b/drivers/char/vt.c
@@ -2274,7 +2274,7 @@ rescan_last_byte:
2274 continue; /* nothing to display */ 2274 continue; /* nothing to display */
2275 } 2275 }
2276 /* Glyph not found */ 2276 /* Glyph not found */
2277 if ((!(vc->vc_utf && !vc->vc_disp_ctrl) && c < 128) && !(c & ~charmask)) { 2277 if ((!(vc->vc_utf && !vc->vc_disp_ctrl) || c < 128) && !(c & ~charmask)) {
2278 /* In legacy mode use the glyph we get by a 1:1 mapping. 2278 /* In legacy mode use the glyph we get by a 1:1 mapping.
2279 This would make absolutely no sense with Unicode in mind, 2279 This would make absolutely no sense with Unicode in mind,
2280 but do this for ASCII characters since a font may lack 2280 but do this for ASCII characters since a font may lack
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-27 20:10:53 -0500