Conflict resolution of af_smc.c from Stephen Rothwell.
Unified · Split
| @@ -78,6 +78,8 @@ ForEachMacros: · 77 unmodified lines | ||
| 78 | 78 | - 'ata_qc_for_each_with_internal' |
| 79 | 79 | - 'ax25_for_each' |
| 80 | 80 | - 'ax25_uid_for_each' |
| 81 | + - '__bio_for_each_bvec' | |
| 82 | + - 'bio_for_each_bvec' | |
| 81 | 83 | - 'bio_for_each_integrity_vec' |
| 82 | 84 | - '__bio_for_each_segment' |
| 83 | 85 | - 'bio_for_each_segment' |
| @@ -118,10 +120,12 @@ ForEachMacros: · 34 unmodified lines | ||
| 118 | 120 | - 'drm_for_each_legacy_plane' |
| 119 | 121 | - 'drm_for_each_plane' |
| 120 | 122 | - 'drm_for_each_plane_mask' |
| 123 | + - 'drm_for_each_privobj' | |
| 121 | 124 | - 'drm_mm_for_each_hole' |
| 122 | 125 | - 'drm_mm_for_each_node' |
| 123 | 126 | - 'drm_mm_for_each_node_in_range' |
| 124 | 127 | - 'drm_mm_for_each_node_safe' |
| 128 | + - 'flow_action_for_each' | |
| 125 | 129 | - 'for_each_active_drhd_unit' |
| 126 | 130 | - 'for_each_active_iommu' |
| 127 | 131 | - 'for_each_available_child_of_node' |
| @@ -158,6 +162,9 @@ ForEachMacros: · 30 unmodified lines | ||
| 158 | 162 | - 'for_each_dss_dev' |
| 159 | 163 | - 'for_each_efi_memory_desc' |
| 160 | 164 | - 'for_each_efi_memory_desc_in_map' |
| 165 | + - 'for_each_element' | |
| 166 | + - 'for_each_element_extid' | |
| 167 | + - 'for_each_element_id' | |
| 161 | 168 | - 'for_each_endpoint_of_node' |
| 162 | 169 | - 'for_each_evictable_lru' |
| 163 | 170 | - 'for_each_fib6_node_rt_rcu' |
| @@ -195,6 +202,7 @@ ForEachMacros: · 31 unmodified lines | ||
| 195 | 202 | - 'for_each_net_rcu' |
| 196 | 203 | - 'for_each_new_connector_in_state' |
| 197 | 204 | - 'for_each_new_crtc_in_state' |
| 205 | + - 'for_each_new_mst_mgr_in_state' | |
| 198 | 206 | - 'for_each_new_plane_in_state' |
| 199 | 207 | - 'for_each_new_private_obj_in_state' |
| 200 | 208 | - 'for_each_node' |
| @@ -210,8 +218,10 @@ ForEachMacros: · 9 unmodified lines | ||
| 210 | 218 | - 'for_each_of_pci_range' |
| 211 | 219 | - 'for_each_old_connector_in_state' |
| 212 | 220 | - 'for_each_old_crtc_in_state' |
| 221 | + - 'for_each_old_mst_mgr_in_state' | |
| 213 | 222 | - 'for_each_oldnew_connector_in_state' |
| 214 | 223 | - 'for_each_oldnew_crtc_in_state' |
| 224 | + - 'for_each_oldnew_mst_mgr_in_state' | |
| 215 | 225 | - 'for_each_oldnew_plane_in_state' |
| 216 | 226 | - 'for_each_oldnew_plane_in_state_reverse' |
| 217 | 227 | - 'for_each_oldnew_private_obj_in_state' |
| @@ -243,6 +253,9 @@ ForEachMacros: · 25 unmodified lines | ||
| 243 | 253 | - 'for_each_sg_dma_page' |
| 244 | 254 | - 'for_each_sg_page' |
| 245 | 255 | - 'for_each_sibling_event' |
| 256 | + - 'for_each_subelement' | |
| 257 | + - 'for_each_subelement_extid' | |
| 258 | + - 'for_each_subelement_id' | |
| 246 | 259 | - '__for_each_thread' |
| 247 | 260 | - 'for_each_thread' |
| 248 | 261 | - 'for_each_zone' |
| @@ -252,6 +265,8 @@ ForEachMacros: · 3 unmodified lines | ||
| 252 | 265 | - 'fwnode_for_each_child_node' |
| 253 | 266 | - 'fwnode_graph_for_each_endpoint' |
| 254 | 267 | - 'gadget_for_each_ep' |
| 268 | + - 'genradix_for_each' | |
| 269 | + - 'genradix_for_each_from' | |
| 255 | 270 | - 'hash_for_each' |
| 256 | 271 | - 'hash_for_each_possible' |
| 257 | 272 | - 'hash_for_each_possible_rcu' |
| @@ -293,7 +308,11 @@ ForEachMacros: · 35 unmodified lines | ||
| 293 | 308 | - 'key_for_each' |
| 294 | 309 | - 'key_for_each_safe' |
| 295 | 310 | - 'klp_for_each_func' |
| 311 | + - 'klp_for_each_func_safe' | |
| 312 | + - 'klp_for_each_func_static' | |
| 296 | 313 | - 'klp_for_each_object' |
| 314 | + - 'klp_for_each_object_safe' | |
| 315 | + - 'klp_for_each_object_static' | |
| 297 | 316 | - 'kvm_for_each_memslot' |
| 298 | 317 | - 'kvm_for_each_vcpu' |
| 299 | 318 | - 'list_for_each' |
| @@ -324,6 +343,8 @@ ForEachMacros: · 24 unmodified lines | ||
| 324 | 343 | - 'media_device_for_each_intf' |
| 325 | 344 | - 'media_device_for_each_link' |
| 326 | 345 | - 'media_device_for_each_pad' |
| 346 | + - 'mp_bvec_for_each_page' | |
| 347 | + - 'mp_bvec_for_each_segment' | |
| 327 | 348 | - 'nanddev_io_for_each_page' |
| 328 | 349 | - 'netdev_for_each_lower_dev' |
| 329 | 350 | - 'netdev_for_each_lower_private' |
| @@ -375,6 +396,7 @@ ForEachMacros: · 45 unmodified lines | ||
| 375 | 396 | - 'rht_for_each_rcu' |
| 376 | 397 | - 'rht_for_each_rcu_from' |
| 377 | 398 | - '__rq_for_each_bio' |
| 399 | + - 'rq_for_each_bvec' | |
| 378 | 400 | - 'rq_for_each_segment' |
| 379 | 401 | - 'scsi_for_each_prot_sg' |
| 380 | 402 | - 'scsi_for_each_sg' |
| @@ -410,6 +432,8 @@ ForEachMacros: · 29 unmodified lines | ||
| 410 | 432 | - 'v4l2_m2m_for_each_src_buf_safe' |
| 411 | 433 | - 'virtio_device_for_each_vq' |
| 412 | 434 | - 'xa_for_each' |
| 435 | + - 'xa_for_each_marked' | |
| 436 | + - 'xa_for_each_start' | |
| 413 | 437 | - 'xas_for_each' |
| 414 | 438 | - 'xas_for_each_conflict' |
| 415 | 439 | - 'xas_for_each_marked' |
| @@ -1009,16 +1009,18 @@ The kernel interface functions are as follows: · 1008 unmodified lines | ||
| 1009 | 1009 | |
| 1010 | 1010 | (*) Check call still alive. |
| 1011 | 1011 | |
| 1012 | − u32 rxrpc_kernel_check_life(struct socket *sock, | |
| 1013 | − struct rxrpc_call *call); | |
| 1012 | + bool rxrpc_kernel_check_life(struct socket *sock, | |
| 1013 | + struct rxrpc_call *call, | |
| 1014 | + u32 *_life); | |
| 1014 | 1015 | void rxrpc_kernel_probe_life(struct socket *sock, |
| 1015 | 1016 | struct rxrpc_call *call); |
| 1016 | 1017 | |
| 1017 | − The first function returns a number that is updated when ACKs are received | |
| 1018 | − from the peer (notably including PING RESPONSE ACKs which we can elicit by | |
| 1019 | − sending PING ACKs to see if the call still exists on the server). The | |
| 1020 | − caller should compare the numbers of two calls to see if the call is still | |
| 1021 | − alive after waiting for a suitable interval. | |
| 1018 | + The first function passes back in *_life a number that is updated when | |
| 1019 | + ACKs are received from the peer (notably including PING RESPONSE ACKs | |
| 1020 | + which we can elicit by sending PING ACKs to see if the call still exists | |
| 1021 | + on the server). The caller should compare the numbers of two calls to see | |
| 1022 | + if the call is still alive after waiting for a suitable interval. It also | |
| 1023 | + returns true as long as the call hasn't yet reached the completed state. | |
| 1022 | 1024 | |
| 1023 | 1025 | This allows the caller to work out if the server is still contactable and |
| 1024 | 1026 | if the call is still alive on the server while waiting for the server to |
| @@ -10139,7 +10139,7 @@ F: drivers/spi/spi-at91-usart.c · 10138 unmodified lines | ||
| 10139 | 10139 | F: Documentation/devicetree/bindings/mfd/atmel-usart.txt |
| 10140 | 10140 | |
| 10141 | 10141 | MICROCHIP KSZ SERIES ETHERNET SWITCH DRIVER |
| 10142 | −M: Woojung Huh <Woojung.Huh@microchip.com> | |
| 10142 | +M: Woojung Huh <woojung.huh@microchip.com> | |
| 10143 | 10143 | M: Microchip Linux Driver Support <UNGLinuxDriver@microchip.com> |
| 10144 | 10144 | L: netdev@vger.kernel.org |
| 10145 | 10145 | S: Maintained |
| @@ -16503,7 +16503,7 @@ F: drivers/char/virtio_console.c · 6357 unmodified lines | ||
| 16503 | 16503 | F: include/linux/virtio_console.h |
| 16504 | 16504 | F: include/uapi/linux/virtio_console.h |
| 16505 | 16505 | |
| 16506 | −VIRTIO CORE, NET AND BLOCK DRIVERS | |
| 16506 | +VIRTIO CORE AND NET DRIVERS | |
| 16507 | 16507 | M: "Michael S. Tsirkin" <mst@redhat.com> |
| 16508 | 16508 | M: Jason Wang <jasowang@redhat.com> |
| 16509 | 16509 | L: virtualization@lists.linux-foundation.org |
| @@ -16518,6 +16518,19 @@ F: include/uapi/linux/virtio_*.h · 8 unmodified lines | ||
| 16518 | 16518 | F: drivers/crypto/virtio/ |
| 16519 | 16519 | F: mm/balloon_compaction.c |
| 16520 | 16520 | |
| 16521 | +VIRTIO BLOCK AND SCSI DRIVERS | |
| 16522 | +M: "Michael S. Tsirkin" <mst@redhat.com> | |
| 16523 | +M: Jason Wang <jasowang@redhat.com> | |
| 16524 | +R: Paolo Bonzini <pbonzini@redhat.com> | |
| 16525 | +R: Stefan Hajnoczi <stefanha@redhat.com> | |
| 16526 | +L: virtualization@lists.linux-foundation.org | |
| 16527 | +S: Maintained | |
| 16528 | +F: drivers/block/virtio_blk.c | |
| 16529 | +F: drivers/scsi/virtio_scsi.c | |
| 16530 | +F: include/uapi/linux/virtio_blk.h | |
| 16531 | +F: include/uapi/linux/virtio_scsi.h | |
| 16532 | +F: drivers/vhost/scsi.c | |
| 16533 | + | |
| 16521 | 16534 | VIRTIO CRYPTO DRIVER |
| 16522 | 16535 | M: Gonglei <arei.gonglei@huawei.com> |
| 16523 | 16536 | L: virtualization@lists.linux-foundation.org |
| @@ -2,7 +2,7 @@ · 1 unmodified line | ||
| 2 | 2 | VERSION = 5 |
| 3 | 3 | PATCHLEVEL = 1 |
| 4 | 4 | SUBLEVEL = 0 |
| 5 | −EXTRAVERSION = -rc4 | |
| 5 | +EXTRAVERSION = -rc5 | |
| 6 | 6 | NAME = Shy Crocodile |
| 7 | 7 | |
| 8 | 8 | # *DOCUMENTATION* |
| @@ -30,8 +30,8 @@ do { \ · 29 unmodified lines | ||
| 30 | 30 | " prfm pstl1strm, %2\n" \ |
| 31 | 31 | "1: ldxr %w1, %2\n" \ |
| 32 | 32 | insn "\n" \ |
| 33 | −"2: stlxr %w3, %w0, %2\n" \ | |
| 34 | −" cbnz %w3, 1b\n" \ | |
| 33 | +"2: stlxr %w0, %w3, %2\n" \ | |
| 34 | +" cbnz %w0, 1b\n" \ | |
| 35 | 35 | " dmb ish\n" \ |
| 36 | 36 | "3:\n" \ |
| 37 | 37 | " .pushsection .fixup,\"ax\"\n" \ |
| @@ -50,30 +50,30 @@ do { \ · 12 unmodified lines | ||
| 50 | 50 | static inline int |
| 51 | 51 | arch_futex_atomic_op_inuser(int op, int oparg, int *oval, u32 __user *_uaddr) |
| 52 | 52 | { |
| 53 | − int oldval = 0, ret, tmp; | |
| 53 | + int oldval, ret, tmp; | |
| 54 | 54 | u32 __user *uaddr = __uaccess_mask_ptr(_uaddr); |
| 55 | 55 | |
| 56 | 56 | pagefault_disable(); |
| 57 | 57 | |
| 58 | 58 | switch (op) { |
| 59 | 59 | case FUTEX_OP_SET: |
| 60 | − __futex_atomic_op("mov %w0, %w4", | |
| 60 | + __futex_atomic_op("mov %w3, %w4", | |
| 61 | 61 | ret, oldval, uaddr, tmp, oparg); |
| 62 | 62 | break; |
| 63 | 63 | case FUTEX_OP_ADD: |
| 64 | − __futex_atomic_op("add %w0, %w1, %w4", | |
| 64 | + __futex_atomic_op("add %w3, %w1, %w4", | |
| 65 | 65 | ret, oldval, uaddr, tmp, oparg); |
| 66 | 66 | break; |
| 67 | 67 | case FUTEX_OP_OR: |
| 68 | − __futex_atomic_op("orr %w0, %w1, %w4", | |
| 68 | + __futex_atomic_op("orr %w3, %w1, %w4", | |
| 69 | 69 | ret, oldval, uaddr, tmp, oparg); |
| 70 | 70 | break; |
| 71 | 71 | case FUTEX_OP_ANDN: |
| 72 | − __futex_atomic_op("and %w0, %w1, %w4", | |
| 72 | + __futex_atomic_op("and %w3, %w1, %w4", | |
| 73 | 73 | ret, oldval, uaddr, tmp, ~oparg); |
| 74 | 74 | break; |
| 75 | 75 | case FUTEX_OP_XOR: |
| 76 | − __futex_atomic_op("eor %w0, %w1, %w4", | |
| 76 | + __futex_atomic_op("eor %w3, %w1, %w4", | |
| 77 | 77 | ret, oldval, uaddr, tmp, oparg); |
| 78 | 78 | break; |
| 79 | 79 | default: |
| @@ -73,4 +73,9 @@ static inline bool is_forbidden_offset_for_adrp(void *place) · 72 unmodified lines | ||
| 73 | 73 | struct plt_entry get_plt_entry(u64 dst, void *pc); |
| 74 | 74 | bool plt_entries_equal(const struct plt_entry *a, const struct plt_entry *b); |
| 75 | 75 | |
| 76 | +static inline bool plt_entry_is_initialized(const struct plt_entry *e) | |
| 77 | +{ | |
| 78 | + return e->adrp || e->add || e->br; | |
| 79 | +} | |
| 80 | + | |
| 76 | 81 | #endif /* __ASM_MODULE_H */ |
| @@ -107,8 +107,7 @@ int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr) · 106 unmodified lines | ||
| 107 | 107 | trampoline = get_plt_entry(addr, mod->arch.ftrace_trampoline); |
| 108 | 108 | if (!plt_entries_equal(mod->arch.ftrace_trampoline, |
| 109 | 109 | &trampoline)) { |
| 110 | − if (!plt_entries_equal(mod->arch.ftrace_trampoline, | |
| 111 | − &(struct plt_entry){})) { | |
| 110 | + if (plt_entry_is_initialized(mod->arch.ftrace_trampoline)) { | |
| 112 | 111 | pr_err("ftrace: far branches to multiple entry points unsupported inside a single module\n"); |
| 113 | 112 | return -EINVAL; |
| 114 | 113 | } |
| @@ -102,10 +102,16 @@ static void dump_instr(const char *lvl, struct pt_regs *regs) · 101 unmodified lines | ||
| 102 | 102 | void dump_backtrace(struct pt_regs *regs, struct task_struct *tsk) |
| 103 | 103 | { |
| 104 | 104 | struct stackframe frame; |
| 105 | − int skip; | |
| 105 | + int skip = 0; | |
| 106 | 106 | |
| 107 | 107 | pr_debug("%s(regs = %p tsk = %p)\n", __func__, regs, tsk); |
| 108 | 108 | |
| 109 | + if (regs) { | |
| 110 | + if (user_mode(regs)) | |
| 111 | + return; | |
| 112 | + skip = 1; | |
| 113 | + } | |
| 114 | + | |
| 109 | 115 | if (!tsk) |
| 110 | 116 | tsk = current; |
| 111 | 117 | |
| @@ -126,7 +132,6 @@ void dump_backtrace(struct pt_regs *regs, struct task_struct *tsk) · 14 unmodified lines | ||
| 126 | 132 | frame.graph = 0; |
| 127 | 133 | #endif |
| 128 | 134 | |
| 129 | − skip = !!regs; | |
| 130 | 135 | printk("Call trace:\n"); |
| 131 | 136 | do { |
| 132 | 137 | /* skip until specified stack frame */ |
| @@ -176,15 +181,13 @@ static int __die(const char *str, int err, struct pt_regs *regs) · 43 unmodified lines | ||
| 176 | 181 | return ret; |
| 177 | 182 | |
| 178 | 183 | print_modules(); |
| 179 | − __show_regs(regs); | |
| 180 | 184 | pr_emerg("Process %.*s (pid: %d, stack limit = 0x%p)\n", |
| 181 | 185 | TASK_COMM_LEN, tsk->comm, task_pid_nr(tsk), |
| 182 | 186 | end_of_stack(tsk)); |
| 187 | + show_regs(regs); | |
| 183 | 188 | |
| 184 | − if (!user_mode(regs)) { | |
| 185 | − dump_backtrace(regs, tsk); | |
| 189 | + if (!user_mode(regs)) | |
| 186 | 190 | dump_instr(KERN_EMERG, regs); |
| 187 | − } | |
| 188 | 191 | |
| 189 | 192 | return ret; |
| 190 | 193 | } |
| @@ -1,6 +1,10 @@ | ||
| 1 | 1 | # require CONFIG_CPU_MIPS32_R2=y |
| 2 | 2 | |
| 3 | 3 | CONFIG_LEGACY_BOARD_OCELOT=y |
| 4 | +CONFIG_FIT_IMAGE_FDT_OCELOT=y | |
| 5 | + | |
| 6 | +CONFIG_BRIDGE=y | |
| 7 | +CONFIG_GENERIC_PHY=y | |
| 4 | 8 | |
| 5 | 9 | CONFIG_MTD=y |
| 6 | 10 | CONFIG_MTD_CMDLINE_PARTS=y |
| @@ -19,6 +23,8 @@ CONFIG_SERIAL_8250_CONSOLE=y · 12 unmodified lines | ||
| 19 | 23 | CONFIG_SERIAL_OF_PLATFORM=y |
| 20 | 24 | |
| 21 | 25 | CONFIG_NETDEVICES=y |
| 26 | +CONFIG_NET_SWITCHDEV=y | |
| 27 | +CONFIG_NET_DSA=y | |
| 22 | 28 | CONFIG_MSCC_OCELOT_SWITCH=y |
| 23 | 29 | CONFIG_MSCC_OCELOT_SWITCH_OCELOT=y |
| 24 | 30 | CONFIG_MDIO_MSCC_MIIM=y |
| @@ -35,6 +41,8 @@ CONFIG_SPI_DESIGNWARE=y · 10 unmodified lines | ||
| 35 | 41 | CONFIG_SPI_DW_MMIO=y |
| 36 | 42 | CONFIG_SPI_SPIDEV=y |
| 37 | 43 | |
| 44 | +CONFIG_PINCTRL_OCELOT=y | |
| 45 | + | |
| 38 | 46 | CONFIG_GPIO_SYSFS=y |
| 39 | 47 | |
| 40 | 48 | CONFIG_POWER_RESET=y |
| @@ -33,6 +33,7 @@ · 32 unmodified lines | ||
| 33 | 33 | #include <asm/processor.h> |
| 34 | 34 | #include <asm/sigcontext.h> |
| 35 | 35 | #include <linux/uaccess.h> |
| 36 | +#include <asm/irq_regs.h> | |
| 36 | 37 | |
| 37 | 38 | static struct hard_trap_info { |
| 38 | 39 | unsigned char tt; /* Trap type code for MIPS R3xxx and R4xxx */ |
| @@ -214,7 +215,7 @@ void kgdb_call_nmi_hook(void *ignored) · 175 unmodified lines | ||
| 214 | 215 | old_fs = get_fs(); |
| 215 | 216 | set_fs(KERNEL_DS); |
| 216 | 217 | |
| 217 | − kgdb_nmicallback(raw_smp_processor_id(), NULL); | |
| 218 | + kgdb_nmicallback(raw_smp_processor_id(), get_irq_regs()); | |
| 218 | 219 | |
| 219 | 220 | set_fs(old_fs); |
| 220 | 221 | } |
| @@ -118,7 +118,6 @@ static void shutdown_bridge_irq(struct irq_data *d) · 117 unmodified lines | ||
| 118 | 118 | { |
| 119 | 119 | struct hub_irq_data *hd = irq_data_get_irq_chip_data(d); |
| 120 | 120 | struct bridge_controller *bc; |
| 121 | − int pin = hd->pin; | |
| 122 | 121 | |
| 123 | 122 | if (!hd) |
| 124 | 123 | return; |
| @@ -126,7 +125,7 @@ static void shutdown_bridge_irq(struct irq_data *d) · 1 unmodified line | ||
| 126 | 125 | disable_hub_irq(d); |
| 127 | 126 | |
| 128 | 127 | bc = hd->bc; |
| 129 | − bridge_clr(bc, b_int_enable, (1 << pin)); | |
| 128 | + bridge_clr(bc, b_int_enable, (1 << hd->pin)); | |
| 130 | 129 | bridge_read(bc, b_wid_tflush); |
| 131 | 130 | } |
| 132 | 131 | |
| @@ -352,7 +352,7 @@ static inline bool strict_kernel_rwx_enabled(void) · 351 unmodified lines | ||
| 352 | 352 | #if defined(CONFIG_SPARSEMEM_VMEMMAP) && defined(CONFIG_SPARSEMEM_EXTREME) && \ |
| 353 | 353 | defined (CONFIG_PPC_64K_PAGES) |
| 354 | 354 | #define MAX_PHYSMEM_BITS 51 |
| 355 | −#elif defined(CONFIG_SPARSEMEM) | |
| 355 | +#elif defined(CONFIG_PPC64) | |
| 356 | 356 | #define MAX_PHYSMEM_BITS 46 |
| 357 | 357 | #endif |
| 358 | 358 | |
| @@ -656,11 +656,17 @@ EXC_COMMON_BEGIN(data_access_slb_common) · 655 unmodified lines | ||
| 656 | 656 | ld r4,PACA_EXSLB+EX_DAR(r13) |
| 657 | 657 | std r4,_DAR(r1) |
| 658 | 658 | addi r3,r1,STACK_FRAME_OVERHEAD |
| 659 | +BEGIN_MMU_FTR_SECTION | |
| 660 | + /* HPT case, do SLB fault */ | |
| 659 | 661 | bl do_slb_fault |
| 660 | 662 | cmpdi r3,0 |
| 661 | 663 | bne- 1f |
| 662 | 664 | b fast_exception_return |
| 663 | 665 | 1: /* Error case */ |
| 666 | +MMU_FTR_SECTION_ELSE | |
| 667 | + /* Radix case, access is outside page table range */ | |
| 668 | + li r3,-EFAULT | |
| 669 | +ALT_MMU_FTR_SECTION_END_IFCLR(MMU_FTR_TYPE_RADIX) | |
| 664 | 670 | std r3,RESULT(r1) |
| 665 | 671 | bl save_nvgprs |
| 666 | 672 | RECONCILE_IRQ_STATE(r10, r11) |
| @@ -705,11 +711,17 @@ EXC_COMMON_BEGIN(instruction_access_slb_common) · 38 unmodified lines | ||
| 705 | 711 | EXCEPTION_PROLOG_COMMON(0x480, PACA_EXSLB) |
| 706 | 712 | ld r4,_NIP(r1) |
| 707 | 713 | addi r3,r1,STACK_FRAME_OVERHEAD |
| 714 | +BEGIN_MMU_FTR_SECTION | |
| 715 | + /* HPT case, do SLB fault */ | |
| 708 | 716 | bl do_slb_fault |
| 709 | 717 | cmpdi r3,0 |
| 710 | 718 | bne- 1f |
| 711 | 719 | b fast_exception_return |
| 712 | 720 | 1: /* Error case */ |
| 721 | +MMU_FTR_SECTION_ELSE | |
| 722 | + /* Radix case, access is outside page table range */ | |
| 723 | + li r3,-EFAULT | |
| 724 | +ALT_MMU_FTR_SECTION_END_IFCLR(MMU_FTR_TYPE_RADIX) | |
| 713 | 725 | std r3,RESULT(r1) |
| 714 | 726 | bl save_nvgprs |
| 715 | 727 | RECONCILE_IRQ_STATE(r10, r11) |
| @@ -851,10 +851,6 @@ __secondary_start: · 850 unmodified lines | ||
| 851 | 851 | tophys(r4,r2) |
| 852 | 852 | addi r4,r4,THREAD /* phys address of our thread_struct */ |
| 853 | 853 | mtspr SPRN_SPRG_THREAD,r4 |
| 854 | −#ifdef CONFIG_PPC_RTAS | |
| 855 | − li r3,0 | |
| 856 | − stw r3, RTAS_SP(r4) /* 0 => not in RTAS */ | |
| 857 | −#endif | |
| 858 | 854 | lis r4, (swapper_pg_dir - PAGE_OFFSET)@h |
| 859 | 855 | ori r4, r4, (swapper_pg_dir - PAGE_OFFSET)@l |
| 860 | 856 | mtspr SPRN_SPRG_PGDIR, r4 |
| @@ -941,10 +937,6 @@ start_here: · 80 unmodified lines | ||
| 941 | 937 | tophys(r4,r2) |
| 942 | 938 | addi r4,r4,THREAD /* init task's THREAD */ |
| 943 | 939 | mtspr SPRN_SPRG_THREAD,r4 |
| 944 | −#ifdef CONFIG_PPC_RTAS | |
| 945 | − li r3,0 | |
| 946 | − stw r3, RTAS_SP(r4) /* 0 => not in RTAS */ | |
| 947 | −#endif | |
| 948 | 940 | lis r4, (swapper_pg_dir - PAGE_OFFSET)@h |
| 949 | 941 | ori r4, r4, (swapper_pg_dir - PAGE_OFFSET)@l |
| 950 | 942 | mtspr SPRN_SPRG_PGDIR, r4 |
| @@ -98,7 +98,7 @@ V_FUNCTION_BEGIN(__kernel_clock_gettime) · 97 unmodified lines | ||
| 98 | 98 | * can be used, r7 contains NSEC_PER_SEC. |
| 99 | 99 | */ |
| 100 | 100 | |
| 101 | − lwz r5,WTOM_CLOCK_SEC(r9) | |
| 101 | + lwz r5,(WTOM_CLOCK_SEC+LOPART)(r9) | |
| 102 | 102 | lwz r6,WTOM_CLOCK_NSEC(r9) |
| 103 | 103 | |
| 104 | 104 | /* We now have our offset in r5,r6. We create a fake dependency |
| @@ -0,0 +1,84 @@ | ||
| 1 | +CONFIG_SYSVIPC=y | |
| 2 | +CONFIG_POSIX_MQUEUE=y | |
| 3 | +CONFIG_IKCONFIG=y | |
| 4 | +CONFIG_IKCONFIG_PROC=y | |
| 5 | +CONFIG_CGROUPS=y | |
| 6 | +CONFIG_CGROUP_SCHED=y | |
| 7 | +CONFIG_CFS_BANDWIDTH=y | |
| 8 | +CONFIG_CGROUP_BPF=y | |
| 9 | +CONFIG_NAMESPACES=y | |
| 10 | +CONFIG_USER_NS=y | |
| 11 | +CONFIG_CHECKPOINT_RESTORE=y | |
| 12 | +CONFIG_BLK_DEV_INITRD=y | |
| 13 | +CONFIG_EXPERT=y | |
| 14 | +CONFIG_BPF_SYSCALL=y | |
| 15 | +CONFIG_ARCH_RV32I=y | |
| 16 | +CONFIG_SMP=y | |
| 17 | +CONFIG_MODULES=y | |
| 18 | +CONFIG_MODULE_UNLOAD=y | |
| 19 | +CONFIG_NET=y | |
| 20 | +CONFIG_PACKET=y | |
| 21 | +CONFIG_UNIX=y | |
| 22 | +CONFIG_INET=y | |
| 23 | +CONFIG_IP_MULTICAST=y | |
| 24 | +CONFIG_IP_ADVANCED_ROUTER=y | |
| 25 | +CONFIG_IP_PNP=y | |
| 26 | +CONFIG_IP_PNP_DHCP=y | |
| 27 | +CONFIG_IP_PNP_BOOTP=y | |
| 28 | +CONFIG_IP_PNP_RARP=y | |
| 29 | +CONFIG_NETLINK_DIAG=y | |
| 30 | +CONFIG_PCI=y | |
| 31 | +CONFIG_PCIEPORTBUS=y | |
| 32 | +CONFIG_PCI_HOST_GENERIC=y | |
| 33 | +CONFIG_PCIE_XILINX=y | |
| 34 | +CONFIG_DEVTMPFS=y | |
| 35 | +CONFIG_BLK_DEV_LOOP=y | |
| 36 | +CONFIG_VIRTIO_BLK=y | |
| 37 | +CONFIG_BLK_DEV_SD=y | |
| 38 | +CONFIG_BLK_DEV_SR=y | |
| 39 | +CONFIG_ATA=y | |
| 40 | +CONFIG_SATA_AHCI=y | |
| 41 | +CONFIG_SATA_AHCI_PLATFORM=y | |
| 42 | +CONFIG_NETDEVICES=y | |
| 43 | +CONFIG_VIRTIO_NET=y | |
| 44 | +CONFIG_MACB=y | |
| 45 | +CONFIG_E1000E=y | |
| 46 | +CONFIG_R8169=y | |
| 47 | +CONFIG_MICROSEMI_PHY=y | |
| 48 | +CONFIG_INPUT_MOUSEDEV=y | |
| 49 | +CONFIG_SERIAL_8250=y | |
| 50 | +CONFIG_SERIAL_8250_CONSOLE=y | |
| 51 | +CONFIG_SERIAL_OF_PLATFORM=y | |
| 52 | +CONFIG_SERIAL_EARLYCON_RISCV_SBI=y | |
| 53 | +CONFIG_HVC_RISCV_SBI=y | |
| 54 | +# CONFIG_PTP_1588_CLOCK is not set | |
| 55 | +CONFIG_DRM=y | |
| 56 | +CONFIG_DRM_RADEON=y | |
| 57 | +CONFIG_FRAMEBUFFER_CONSOLE=y | |
| 58 | +CONFIG_USB=y | |
| 59 | +CONFIG_USB_XHCI_HCD=y | |
| 60 | +CONFIG_USB_XHCI_PLATFORM=y | |
| 61 | +CONFIG_USB_EHCI_HCD=y | |
| 62 | +CONFIG_USB_EHCI_HCD_PLATFORM=y | |
| 63 | +CONFIG_USB_OHCI_HCD=y | |
| 64 | +CONFIG_USB_OHCI_HCD_PLATFORM=y | |
| 65 | +CONFIG_USB_STORAGE=y | |
| 66 | +CONFIG_USB_UAS=y | |
| 67 | +CONFIG_VIRTIO_MMIO=y | |
| 68 | +CONFIG_SIFIVE_PLIC=y | |
| 69 | +CONFIG_EXT4_FS=y | |
| 70 | +CONFIG_EXT4_FS_POSIX_ACL=y | |
| 71 | +CONFIG_AUTOFS4_FS=y | |
| 72 | +CONFIG_MSDOS_FS=y | |
| 73 | +CONFIG_VFAT_FS=y | |
| 74 | +CONFIG_TMPFS=y | |
| 75 | +CONFIG_TMPFS_POSIX_ACL=y | |
| 76 | +CONFIG_NFS_FS=y | |
| 77 | +CONFIG_NFS_V4=y | |
| 78 | +CONFIG_NFS_V4_1=y | |
| 79 | +CONFIG_NFS_V4_2=y | |
| 80 | +CONFIG_ROOT_NFS=y | |
| 81 | +CONFIG_CRYPTO_USER_API_HASH=y | |
| 82 | +CONFIG_CRYPTO_DEV_VIRTIO=y | |
| 83 | +CONFIG_PRINTK_TIME=y | |
| 84 | +# CONFIG_RCU_TRACE is not set | |
| @@ -121,6 +121,14 @@ void __init setup_bootmem(void) · 120 unmodified lines | ||
| 121 | 121 | */ |
| 122 | 122 | memblock_reserve(reg->base, vmlinux_end - reg->base); |
| 123 | 123 | mem_size = min(reg->size, (phys_addr_t)-PAGE_OFFSET); |
| 124 | + | |
| 125 | + /* | |
| 126 | + * Remove memblock from the end of usable area to the | |
| 127 | + * end of region | |
| 128 | + */ | |
| 129 | + if (reg->base + mem_size < end) | |
| 130 | + memblock_remove(reg->base + mem_size, | |
| 131 | + end - reg->base - mem_size); | |
| 124 | 132 | } |
| 125 | 133 | } |
| 126 | 134 | BUG_ON(mem_size == 0); |
| @@ -73,6 +73,11 @@ static inline void iommu_batch_start(struct device *dev, unsigned long prot, uns · 72 unmodified lines | ||
| 73 | 73 | p->npages = 0; |
| 74 | 74 | } |
| 75 | 75 | |
| 76 | +static inline bool iommu_use_atu(struct iommu *iommu, u64 mask) | |
| 77 | +{ | |
| 78 | + return iommu->atu && mask > DMA_BIT_MASK(32); | |
| 79 | +} | |
| 80 | + | |
| 76 | 81 | /* Interrupts must be disabled. */ |
| 77 | 82 | static long iommu_batch_flush(struct iommu_batch *p, u64 mask) |
| 78 | 83 | { |
| @@ -92,7 +97,7 @@ static long iommu_batch_flush(struct iommu_batch *p, u64 mask) · 13 unmodified lines | ||
| 92 | 97 | prot &= (HV_PCI_MAP_ATTR_READ | HV_PCI_MAP_ATTR_WRITE); |
| 93 | 98 | |
| 94 | 99 | while (npages != 0) { |
| 95 | − if (mask <= DMA_BIT_MASK(32) || !pbm->iommu->atu) { | |
| 100 | + if (!iommu_use_atu(pbm->iommu, mask)) { | |
| 96 | 101 | num = pci_sun4v_iommu_map(devhandle, |
| 97 | 102 | HV_PCI_TSBID(0, entry), |
| 98 | 103 | npages, |
| @@ -179,7 +184,6 @@ static void *dma_4v_alloc_coherent(struct device *dev, size_t size, · 80 unmodified lines | ||
| 179 | 184 | unsigned long flags, order, first_page, npages, n; |
| 180 | 185 | unsigned long prot = 0; |
| 181 | 186 | struct iommu *iommu; |
| 182 | − struct atu *atu; | |
| 183 | 187 | struct iommu_map_table *tbl; |
| 184 | 188 | struct page *page; |
| 185 | 189 | void *ret; |
| @@ -205,13 +209,11 @@ static void *dma_4v_alloc_coherent(struct device *dev, size_t size, · 19 unmodified lines | ||
| 205 | 209 | memset((char *)first_page, 0, PAGE_SIZE << order); |
| 206 | 210 | |
| 207 | 211 | iommu = dev->archdata.iommu; |
| 208 | − atu = iommu->atu; | |
| 209 | − | |
| 210 | 212 | mask = dev->coherent_dma_mask; |
| 211 | − if (mask <= DMA_BIT_MASK(32) || !atu) | |
| 213 | + if (!iommu_use_atu(iommu, mask)) | |
| 212 | 214 | tbl = &iommu->tbl; |
| 213 | 215 | else |
| 214 | − tbl = &atu->tbl; | |
| 216 | + tbl = &iommu->atu->tbl; | |
| 215 | 217 | |
| 216 | 218 | entry = iommu_tbl_range_alloc(dev, tbl, npages, NULL, |
| 217 | 219 | (unsigned long)(-1), 0); |
| @@ -333,7 +335,7 @@ static void dma_4v_free_coherent(struct device *dev, size_t size, void *cpu, · 115 unmodified lines | ||
| 333 | 335 | atu = iommu->atu; |
| 334 | 336 | devhandle = pbm->devhandle; |
| 335 | 337 | |
| 336 | − if (dvma <= DMA_BIT_MASK(32)) { | |
| 338 | + if (!iommu_use_atu(iommu, dvma)) { | |
| 337 | 339 | tbl = &iommu->tbl; |
| 338 | 340 | iotsb_num = 0; /* we don't care for legacy iommu */ |
| 339 | 341 | } else { |
| @@ -374,7 +376,7 @@ static dma_addr_t dma_4v_map_page(struct device *dev, struct page *page, · 34 unmodified lines | ||
| 374 | 376 | npages >>= IO_PAGE_SHIFT; |
| 375 | 377 | |
| 376 | 378 | mask = *dev->dma_mask; |
| 377 | − if (mask <= DMA_BIT_MASK(32)) | |
| 379 | + if (!iommu_use_atu(iommu, mask)) | |
| 378 | 380 | tbl = &iommu->tbl; |
| 379 | 381 | else |
| 380 | 382 | tbl = &atu->tbl; |
| @@ -510,7 +512,7 @@ static int dma_4v_map_sg(struct device *dev, struct scatterlist *sglist, · 129 unmodified lines | ||
| 510 | 512 | IO_PAGE_SIZE) >> IO_PAGE_SHIFT; |
| 511 | 513 | |
| 512 | 514 | mask = *dev->dma_mask; |
| 513 | − if (mask <= DMA_BIT_MASK(32)) | |
| 515 | + if (!iommu_use_atu(iommu, mask)) | |
| 514 | 516 | tbl = &iommu->tbl; |
| 515 | 517 | else |
| 516 | 518 | tbl = &atu->tbl; |
| @@ -3,10 +3,14 @@ · 2 unmodified lines | ||
| 3 | 3 | #include <linux/types.h> |
| 4 | 4 | #include <linux/init.h> |
| 5 | 5 | #include <linux/slab.h> |
| 6 | +#include <linux/delay.h> | |
| 6 | 7 | #include <asm/apicdef.h> |
| 8 | +#include <asm/nmi.h> | |
| 7 | 9 | |
| 8 | 10 | #include "../perf_event.h" |
| 9 | 11 | |
| 12 | +static DEFINE_PER_CPU(unsigned int, perf_nmi_counter); | |
| 13 | + | |
| 10 | 14 | static __initconst const u64 amd_hw_cache_event_ids |
| 11 | 15 | [PERF_COUNT_HW_CACHE_MAX] |
| 12 | 16 | [PERF_COUNT_HW_CACHE_OP_MAX] |
| @@ -429,6 +433,132 @@ static void amd_pmu_cpu_dead(int cpu) · 416 unmodified lines | ||
| 429 | 433 | } |
| 430 | 434 | } |
| 431 | 435 | |
| 436 | +/* | |
| 437 | + * When a PMC counter overflows, an NMI is used to process the event and | |
| 438 | + * reset the counter. NMI latency can result in the counter being updated | |
| 439 | + * before the NMI can run, which can result in what appear to be spurious | |
| 440 | + * NMIs. This function is intended to wait for the NMI to run and reset | |
| 441 | + * the counter to avoid possible unhandled NMI messages. | |
| 442 | + */ | |
| 443 | +#define OVERFLOW_WAIT_COUNT 50 | |
| 444 | + | |
| 445 | +static void amd_pmu_wait_on_overflow(int idx) | |
| 446 | +{ | |
| 447 | + unsigned int i; | |
| 448 | + u64 counter; | |
| 449 | + | |
| 450 | + /* | |
| 451 | + * Wait for the counter to be reset if it has overflowed. This loop | |
| 452 | + * should exit very, very quickly, but just in case, don't wait | |
| 453 | + * forever... | |
| 454 | + */ | |
| 455 | + for (i = 0; i < OVERFLOW_WAIT_COUNT; i++) { | |
| 456 | + rdmsrl(x86_pmu_event_addr(idx), counter); | |
| 457 | + if (counter & (1ULL << (x86_pmu.cntval_bits - 1))) | |
| 458 | + break; | |
| 459 | + | |
| 460 | + /* Might be in IRQ context, so can't sleep */ | |
| 461 | + udelay(1); | |
| 462 | + } | |
| 463 | +} | |
| 464 | + | |
| 465 | +static void amd_pmu_disable_all(void) | |
| 466 | +{ | |
| 467 | + struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events); | |
| 468 | + int idx; | |
| 469 | + | |
| 470 | + x86_pmu_disable_all(); | |
| 471 | + | |
| 472 | + /* | |
| 473 | + * This shouldn't be called from NMI context, but add a safeguard here | |
| 474 | + * to return, since if we're in NMI context we can't wait for an NMI | |
| 475 | + * to reset an overflowed counter value. | |
| 476 | + */ | |
| 477 | + if (in_nmi()) | |
| 478 | + return; | |
| 479 | + | |
| 480 | + /* | |
| 481 | + * Check each counter for overflow and wait for it to be reset by the | |
| 482 | + * NMI if it has overflowed. This relies on the fact that all active | |
| 483 | + * counters are always enabled when this function is caled and | |
| 484 | + * ARCH_PERFMON_EVENTSEL_INT is always set. | |
| 485 | + */ | |
| 486 | + for (idx = 0; idx < x86_pmu.num_counters; idx++) { | |
| 487 | + if (!test_bit(idx, cpuc->active_mask)) | |
| 488 | + continue; | |
| 489 | + | |
| 490 | + amd_pmu_wait_on_overflow(idx); | |
| 491 | + } | |
| 492 | +} | |
| 493 | + | |
| 494 | +static void amd_pmu_disable_event(struct perf_event *event) | |
| 495 | +{ | |
| 496 | + x86_pmu_disable_event(event); | |
| 497 | + | |
| 498 | + /* | |
| 499 | + * This can be called from NMI context (via x86_pmu_stop). The counter | |
| 500 | + * may have overflowed, but either way, we'll never see it get reset | |
| 501 | + * by the NMI if we're already in the NMI. And the NMI latency support | |
| 502 | + * below will take care of any pending NMI that might have been | |
| 503 | + * generated by the overflow. | |
| 504 | + */ | |
| 505 | + if (in_nmi()) | |
| 506 | + return; | |
| 507 | + | |
| 508 | + amd_pmu_wait_on_overflow(event->hw.idx); | |
| 509 | +} | |
| 510 | + | |
| 511 | +/* | |
| 512 | + * Because of NMI latency, if multiple PMC counters are active or other sources | |
| 513 | + * of NMIs are received, the perf NMI handler can handle one or more overflowed | |
| 514 | + * PMC counters outside of the NMI associated with the PMC overflow. If the NMI | |
| 515 | + * doesn't arrive at the LAPIC in time to become a pending NMI, then the kernel | |
| 516 | + * back-to-back NMI support won't be active. This PMC handler needs to take into | |
| 517 | + * account that this can occur, otherwise this could result in unknown NMI | |
| 518 | + * messages being issued. Examples of this is PMC overflow while in the NMI | |
| 519 | + * handler when multiple PMCs are active or PMC overflow while handling some | |
| 520 | + * other source of an NMI. | |
| 521 | + * | |
| 522 | + * Attempt to mitigate this by using the number of active PMCs to determine | |
| 523 | + * whether to return NMI_HANDLED if the perf NMI handler did not handle/reset | |
| 524 | + * any PMCs. The per-CPU perf_nmi_counter variable is set to a minimum of the | |
| 525 | + * number of active PMCs or 2. The value of 2 is used in case an NMI does not | |
| 526 | + * arrive at the LAPIC in time to be collapsed into an already pending NMI. | |
| 527 | + */ | |
| 528 | +static int amd_pmu_handle_irq(struct pt_regs *regs) | |
| 529 | +{ | |
| 530 | + struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events); | |
| 531 | + int active, handled; | |
| 532 | + | |
| 533 | + /* | |
| 534 | + * Obtain the active count before calling x86_pmu_handle_irq() since | |
| 535 | + * it is possible that x86_pmu_handle_irq() may make a counter | |
| 536 | + * inactive (through x86_pmu_stop). | |
| 537 | + */ | |
| 538 | + active = __bitmap_weight(cpuc->active_mask, X86_PMC_IDX_MAX); | |
| 539 | + | |
| 540 | + /* Process any counter overflows */ | |
| 541 | + handled = x86_pmu_handle_irq(regs); | |
| 542 | + | |
| 543 | + /* | |
| 544 | + * If a counter was handled, record the number of possible remaining | |
| 545 | + * NMIs that can occur. | |
| 546 | + */ | |
| 547 | + if (handled) { | |
| 548 | + this_cpu_write(perf_nmi_counter, | |
| 549 | + min_t(unsigned int, 2, active)); | |
| 550 | + | |
| 551 | + return handled; | |
| 552 | + } | |
| 553 | + | |
| 554 | + if (!this_cpu_read(perf_nmi_counter)) | |
| 555 | + return NMI_DONE; | |
| 556 | + | |
| 557 | + this_cpu_dec(perf_nmi_counter); | |
| 558 | + | |
| 559 | + return NMI_HANDLED; | |
| 560 | +} | |
| 561 | + | |
| 432 | 562 | static struct event_constraint * |
| 433 | 563 | amd_get_event_constraints(struct cpu_hw_events *cpuc, int idx, |
| 434 | 564 | struct perf_event *event) |
| @@ -621,11 +751,11 @@ static ssize_t amd_event_sysfs_show(char *page, u64 config) · 186 unmodified lines | ||
| 621 | 751 | |
| 622 | 752 | static __initconst const struct x86_pmu amd_pmu = { |
| 623 | 753 | .name = "AMD", |
| 624 | − .handle_irq = x86_pmu_handle_irq, | |
| 625 | − .disable_all = x86_pmu_disable_all, | |
| 754 | + .handle_irq = amd_pmu_handle_irq, | |
| 755 | + .disable_all = amd_pmu_disable_all, | |
| 626 | 756 | .enable_all = x86_pmu_enable_all, |
| 627 | 757 | .enable = x86_pmu_enable_event, |
| 628 | − .disable = x86_pmu_disable_event, | |
| 758 | + .disable = amd_pmu_disable_event, | |
| 629 | 759 | .hw_config = amd_pmu_hw_config, |
| 630 | 760 | .schedule_events = x86_schedule_events, |
| 631 | 761 | .eventsel = MSR_K7_EVNTSEL0, |
| @@ -732,7 +862,7 @@ void amd_pmu_enable_virt(void) · 100 unmodified lines | ||
| 732 | 862 | cpuc->perf_ctr_virt_mask = 0; |
| 733 | 863 | |
| 734 | 864 | /* Reload all events */ |
| 735 | − x86_pmu_disable_all(); | |
| 865 | + amd_pmu_disable_all(); | |
| 736 | 866 | x86_pmu_enable_all(0); |
| 737 | 867 | } |
| 738 | 868 | EXPORT_SYMBOL_GPL(amd_pmu_enable_virt); |
| @@ -750,7 +880,7 @@ void amd_pmu_disable_virt(void) · 11 unmodified lines | ||
| 750 | 880 | cpuc->perf_ctr_virt_mask = AMD64_EVENTSEL_HOSTONLY; |
| 751 | 881 | |
| 752 | 882 | /* Reload all events */ |
| 753 | − x86_pmu_disable_all(); | |
| 883 | + amd_pmu_disable_all(); | |
| 754 | 884 | x86_pmu_enable_all(0); |
| 755 | 885 | } |
| 756 | 886 | EXPORT_SYMBOL_GPL(amd_pmu_disable_virt); |
| @@ -1349,8 +1349,9 @@ void x86_pmu_stop(struct perf_event *event, int flags) · 1348 unmodified lines | ||
| 1349 | 1349 | struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events); |
| 1350 | 1350 | struct hw_perf_event *hwc = &event->hw; |
| 1351 | 1351 | |
| 1352 | − if (__test_and_clear_bit(hwc->idx, cpuc->active_mask)) { | |
| 1352 | + if (test_bit(hwc->idx, cpuc->active_mask)) { | |
| 1353 | 1353 | x86_pmu.disable(event); |
| 1354 | + __clear_bit(hwc->idx, cpuc->active_mask); | |
| 1354 | 1355 | cpuc->events[hwc->idx] = NULL; |
| 1355 | 1356 | WARN_ON_ONCE(hwc->state & PERF_HES_STOPPED); |
| 1356 | 1357 | hwc->state |= PERF_HES_STOPPED; |
| @@ -1447,16 +1448,8 @@ int x86_pmu_handle_irq(struct pt_regs *regs) · 90 unmodified lines | ||
| 1447 | 1448 | apic_write(APIC_LVTPC, APIC_DM_NMI); |
| 1448 | 1449 | |
| 1449 | 1450 | for (idx = 0; idx < x86_pmu.num_counters; idx++) { |
| 1450 | − if (!test_bit(idx, cpuc->active_mask)) { | |
| 1451 | − /* | |
| 1452 | − * Though we deactivated the counter some cpus | |
| 1453 | − * might still deliver spurious interrupts still | |
| 1454 | − * in flight. Catch them: | |
| 1455 | − */ | |
| 1456 | − if (__test_and_clear_bit(idx, cpuc->running)) | |
| 1457 | − handled++; | |
| 1451 | + if (!test_bit(idx, cpuc->active_mask)) | |
| 1458 | 1452 | continue; |
| 1459 | − } | |
| 1460 | 1453 | |
| 1461 | 1454 | event = cpuc->events[idx]; |
| 1462 | 1455 | |
| @@ -3185,7 +3185,7 @@ static int intel_pmu_hw_config(struct perf_event *event) · 3184 unmodified lines | ||
| 3185 | 3185 | return ret; |
| 3186 | 3186 | |
| 3187 | 3187 | if (event->attr.precise_ip) { |
| 3188 | − if (!event->attr.freq) { | |
| 3188 | + if (!(event->attr.freq || event->attr.wakeup_events)) { | |
| 3189 | 3189 | event->hw.flags |= PERF_X86_EVENT_AUTO_RELOAD; |
| 3190 | 3190 | if (!(event->attr.sample_type & |
| 3191 | 3191 | ~intel_pmu_large_pebs_flags(event))) |
| @@ -3575,6 +3575,12 @@ static void intel_pmu_cpu_starting(int cpu) · 383 unmodified lines | ||
| 3575 | 3575 | |
| 3576 | 3576 | cpuc->lbr_sel = NULL; |
| 3577 | 3577 | |
| 3578 | + if (x86_pmu.flags & PMU_FL_TFA) { | |
| 3579 | + WARN_ON_ONCE(cpuc->tfa_shadow); | |
| 3580 | + cpuc->tfa_shadow = ~0ULL; | |
| 3581 | + intel_set_tfa(cpuc, false); | |
| 3582 | + } | |
| 3583 | + | |
| 3578 | 3584 | if (x86_pmu.version > 1) |
| 3579 | 3585 | flip_smm_bit(&x86_pmu.attr_freeze_on_smi); |
| 3580 | 3586 | |
| @@ -36,16 +36,17 @@ · 35 unmodified lines | ||
| 36 | 36 | * bit 0 is the LSB of addr; bit 32 is the LSB of (addr+1). |
| 37 | 37 | */ |
| 38 | 38 | |
| 39 | −#define BITOP_ADDR(x) "+m" (*(volatile long *) (x)) | |
| 39 | +#define RLONG_ADDR(x) "m" (*(volatile long *) (x)) | |
| 40 | +#define WBYTE_ADDR(x) "+m" (*(volatile char *) (x)) | |
| 40 | 41 | |
| 41 | −#define ADDR BITOP_ADDR(addr) | |
| 42 | +#define ADDR RLONG_ADDR(addr) | |
| 42 | 43 | |
| 43 | 44 | /* |
| 44 | 45 | * We do the locked ops that don't return the old value as |
| 45 | 46 | * a mask operation on a byte. |
| 46 | 47 | */ |
| 47 | 48 | #define IS_IMMEDIATE(nr) (__builtin_constant_p(nr)) |
| 48 | −#define CONST_MASK_ADDR(nr, addr) BITOP_ADDR((void *)(addr) + ((nr)>>3)) | |
| 49 | +#define CONST_MASK_ADDR(nr, addr) WBYTE_ADDR((void *)(addr) + ((nr)>>3)) | |
| 49 | 50 | #define CONST_MASK(nr) (1 << ((nr) & 7)) |
| 50 | 51 | |
| 51 | 52 | /** |
| @@ -73,7 +74,7 @@ set_bit(long nr, volatile unsigned long *addr) · 21 unmodified lines | ||
| 73 | 74 | : "memory"); |
| 74 | 75 | } else { |
| 75 | 76 | asm volatile(LOCK_PREFIX __ASM_SIZE(bts) " %1,%0" |
| 76 | − : BITOP_ADDR(addr) : "Ir" (nr) : "memory"); | |
| 77 | + : : RLONG_ADDR(addr), "Ir" (nr) : "memory"); | |
| 77 | 78 | } |
| 78 | 79 | } |
| 79 | 80 | |
| @@ -88,7 +89,7 @@ set_bit(long nr, volatile unsigned long *addr) · 8 unmodified lines | ||
| 88 | 89 | */ |
| 89 | 90 | static __always_inline void __set_bit(long nr, volatile unsigned long *addr) |
| 90 | 91 | { |
| 91 | − asm volatile(__ASM_SIZE(bts) " %1,%0" : ADDR : "Ir" (nr) : "memory"); | |
| 92 | + asm volatile(__ASM_SIZE(bts) " %1,%0" : : ADDR, "Ir" (nr) : "memory"); | |
| 92 | 93 | } |
| 93 | 94 | |
| 94 | 95 | /** |
| @@ -110,8 +111,7 @@ clear_bit(long nr, volatile unsigned long *addr) · 15 unmodified lines | ||
| 110 | 111 | : "iq" ((u8)~CONST_MASK(nr))); |
| 111 | 112 | } else { |
| 112 | 113 | asm volatile(LOCK_PREFIX __ASM_SIZE(btr) " %1,%0" |
| 113 | − : BITOP_ADDR(addr) | |
| 114 | − : "Ir" (nr)); | |
| 114 | + : : RLONG_ADDR(addr), "Ir" (nr) : "memory"); | |
| 115 | 115 | } |
| 116 | 116 | } |
| 117 | 117 | |
| @@ -131,7 +131,7 @@ static __always_inline void clear_bit_unlock(long nr, volatile unsigned long *ad · 13 unmodified lines | ||
| 131 | 131 | |
| 132 | 132 | static __always_inline void __clear_bit(long nr, volatile unsigned long *addr) |
| 133 | 133 | { |
| 134 | − asm volatile(__ASM_SIZE(btr) " %1,%0" : ADDR : "Ir" (nr)); | |
| 134 | + asm volatile(__ASM_SIZE(btr) " %1,%0" : : ADDR, "Ir" (nr) : "memory"); | |
| 135 | 135 | } |
| 136 | 136 | |
| 137 | 137 | static __always_inline bool clear_bit_unlock_is_negative_byte(long nr, volatile unsigned long *addr) |
| @@ -139,7 +139,7 @@ static __always_inline bool clear_bit_unlock_is_negative_byte(long nr, volatile · 1 unmodified line | ||
| 139 | 139 | bool negative; |
| 140 | 140 | asm volatile(LOCK_PREFIX "andb %2,%1" |
| 141 | 141 | CC_SET(s) |
| 142 | − : CC_OUT(s) (negative), ADDR | |
| 142 | + : CC_OUT(s) (negative), WBYTE_ADDR(addr) | |
| 143 | 143 | : "ir" ((char) ~(1 << nr)) : "memory"); |
| 144 | 144 | return negative; |
| 145 | 145 | } |
| @@ -155,13 +155,9 @@ static __always_inline bool clear_bit_unlock_is_negative_byte(long nr, volatile · 9 unmodified lines | ||
| 155 | 155 | * __clear_bit() is non-atomic and implies release semantics before the memory |
| 156 | 156 | * operation. It can be used for an unlock if no other CPUs can concurrently |
| 157 | 157 | * modify other bits in the word. |
| 158 | − * | |
| 159 | − * No memory barrier is required here, because x86 cannot reorder stores past | |
| 160 | − * older loads. Same principle as spin_unlock. | |
| 161 | 158 | */ |
| 162 | 159 | static __always_inline void __clear_bit_unlock(long nr, volatile unsigned long *addr) |
| 163 | 160 | { |
| 164 | − barrier(); | |
| 165 | 161 | __clear_bit(nr, addr); |
| 166 | 162 | } |
| 167 | 163 | |
| @@ -176,7 +172,7 @@ static __always_inline void __clear_bit_unlock(long nr, volatile unsigned long * · 8 unmodified lines | ||
| 176 | 172 | */ |
| 177 | 173 | static __always_inline void __change_bit(long nr, volatile unsigned long *addr) |
| 178 | 174 | { |
| 179 | − asm volatile(__ASM_SIZE(btc) " %1,%0" : ADDR : "Ir" (nr)); | |
| 175 | + asm volatile(__ASM_SIZE(btc) " %1,%0" : : ADDR, "Ir" (nr) : "memory"); | |
| 180 | 176 | } |
| 181 | 177 | |
| 182 | 178 | /** |
| @@ -196,8 +192,7 @@ static __always_inline void change_bit(long nr, volatile unsigned long *addr) · 13 unmodified lines | ||
| 196 | 192 | : "iq" ((u8)CONST_MASK(nr))); |
| 197 | 193 | } else { |
| 198 | 194 | asm volatile(LOCK_PREFIX __ASM_SIZE(btc) " %1,%0" |
| 199 | − : BITOP_ADDR(addr) | |
| 200 | − : "Ir" (nr)); | |
| 195 | + : : RLONG_ADDR(addr), "Ir" (nr) : "memory"); | |
| 201 | 196 | } |
| 202 | 197 | } |
| 203 | 198 | |
| @@ -242,8 +237,8 @@ static __always_inline bool __test_and_set_bit(long nr, volatile unsigned long * · 38 unmodified lines | ||
| 242 | 237 | |
| 243 | 238 | asm(__ASM_SIZE(bts) " %2,%1" |
| 244 | 239 | CC_SET(c) |
| 245 | − : CC_OUT(c) (oldbit), ADDR | |
| 246 | − : "Ir" (nr)); | |
| 240 | + : CC_OUT(c) (oldbit) | |
| 241 | + : ADDR, "Ir" (nr) : "memory"); | |
| 247 | 242 | return oldbit; |
| 248 | 243 | } |
| 249 | 244 | |
| @@ -282,8 +277,8 @@ static __always_inline bool __test_and_clear_bit(long nr, volatile unsigned long · 32 unmodified lines | ||
| 282 | 277 | |
| 283 | 278 | asm volatile(__ASM_SIZE(btr) " %2,%1" |
| 284 | 279 | CC_SET(c) |
| 285 | − : CC_OUT(c) (oldbit), ADDR | |
| 286 | − : "Ir" (nr)); | |
| 280 | + : CC_OUT(c) (oldbit) | |
| 281 | + : ADDR, "Ir" (nr) : "memory"); | |
| 287 | 282 | return oldbit; |
| 288 | 283 | } |
| 289 | 284 | |
| @@ -294,8 +289,8 @@ static __always_inline bool __test_and_change_bit(long nr, volatile unsigned lon · 4 unmodified lines | ||
| 294 | 289 | |
| 295 | 290 | asm volatile(__ASM_SIZE(btc) " %2,%1" |
| 296 | 291 | CC_SET(c) |
| 297 | − : CC_OUT(c) (oldbit), ADDR | |
| 298 | − : "Ir" (nr) : "memory"); | |
| 292 | + : CC_OUT(c) (oldbit) | |
| 293 | + : ADDR, "Ir" (nr) : "memory"); | |
| 299 | 294 | |
| 300 | 295 | return oldbit; |
| 301 | 296 | } |
| @@ -326,7 +321,7 @@ static __always_inline bool variable_test_bit(long nr, volatile const unsigned l · 24 unmodified lines | ||
| 326 | 321 | asm volatile(__ASM_SIZE(bt) " %2,%1" |
| 327 | 322 | CC_SET(c) |
| 328 | 323 | : CC_OUT(c) (oldbit) |
| 329 | − : "m" (*(unsigned long *)addr), "Ir" (nr)); | |
| 324 | + : "m" (*(unsigned long *)addr), "Ir" (nr) : "memory"); | |
| 330 | 325 | |
| 331 | 326 | return oldbit; |
| 332 | 327 | } |
| @@ -226,7 +226,9 @@ struct x86_emulate_ops { · 225 unmodified lines | ||
| 226 | 226 | |
| 227 | 227 | unsigned (*get_hflags)(struct x86_emulate_ctxt *ctxt); |
| 228 | 228 | void (*set_hflags)(struct x86_emulate_ctxt *ctxt, unsigned hflags); |
| 229 | − int (*pre_leave_smm)(struct x86_emulate_ctxt *ctxt, u64 smbase); | |
| 229 | + int (*pre_leave_smm)(struct x86_emulate_ctxt *ctxt, | |
| 230 | + const char *smstate); | |
| 231 | + void (*post_leave_smm)(struct x86_emulate_ctxt *ctxt); | |
| 230 | 232 | |
| 231 | 233 | }; |
| 232 | 234 | |
| @@ -126,7 +126,7 @@ static inline gfn_t gfn_to_index(gfn_t gfn, gfn_t base_gfn, int level) · 125 unmodified lines | ||
| 126 | 126 | } |
| 127 | 127 | |
| 128 | 128 | #define KVM_PERMILLE_MMU_PAGES 20 |
| 129 | −#define KVM_MIN_ALLOC_MMU_PAGES 64 | |
| 129 | +#define KVM_MIN_ALLOC_MMU_PAGES 64UL | |
| 130 | 130 | #define KVM_MMU_HASH_SHIFT 12 |
| 131 | 131 | #define KVM_NUM_MMU_PAGES (1 << KVM_MMU_HASH_SHIFT) |
| 132 | 132 | #define KVM_MIN_FREE_MMU_PAGES 5 |
| @@ -844,9 +844,9 @@ enum kvm_irqchip_mode { · 711 unmodified lines | ||
| 844 | 844 | }; |
| 845 | 845 | |
| 846 | 846 | struct kvm_arch { |
| 847 | − unsigned int n_used_mmu_pages; | |
| 848 | − unsigned int n_requested_mmu_pages; | |
| 849 | − unsigned int n_max_mmu_pages; | |
| 847 | + unsigned long n_used_mmu_pages; | |
| 848 | + unsigned long n_requested_mmu_pages; | |
| 849 | + unsigned long n_max_mmu_pages; | |
| 850 | 850 | unsigned int indirect_shadow_pages; |
| 851 | 851 | struct hlist_head mmu_page_hash[KVM_NUM_MMU_PAGES]; |
| 852 | 852 | /* |
| @@ -1182,7 +1182,7 @@ struct kvm_x86_ops { · 329 unmodified lines | ||
| 1182 | 1182 | |
| 1183 | 1183 | int (*smi_allowed)(struct kvm_vcpu *vcpu); |
| 1184 | 1184 | int (*pre_enter_smm)(struct kvm_vcpu *vcpu, char *smstate); |
| 1185 | − int (*pre_leave_smm)(struct kvm_vcpu *vcpu, u64 smbase); | |
| 1185 | + int (*pre_leave_smm)(struct kvm_vcpu *vcpu, const char *smstate); | |
| 1186 | 1186 | int (*enable_smi_window)(struct kvm_vcpu *vcpu); |
| 1187 | 1187 | |
| 1188 | 1188 | int (*mem_enc_op)(struct kvm *kvm, void __user *argp); |
| @@ -1256,8 +1256,8 @@ void kvm_mmu_clear_dirty_pt_masked(struct kvm *kvm, · 67 unmodified lines | ||
| 1256 | 1256 | gfn_t gfn_offset, unsigned long mask); |
| 1257 | 1257 | void kvm_mmu_zap_all(struct kvm *kvm); |
| 1258 | 1258 | void kvm_mmu_invalidate_mmio_sptes(struct kvm *kvm, u64 gen); |
| 1259 | −unsigned int kvm_mmu_calculate_default_mmu_pages(struct kvm *kvm); | |
| 1260 | −void kvm_mmu_change_mmu_pages(struct kvm *kvm, unsigned int kvm_nr_mmu_pages); | |
| 1259 | +unsigned long kvm_mmu_calculate_default_mmu_pages(struct kvm *kvm); | |
| 1260 | +void kvm_mmu_change_mmu_pages(struct kvm *kvm, unsigned long kvm_nr_mmu_pages); | |
| 1261 | 1261 | |
| 1262 | 1262 | int load_pdptrs(struct kvm_vcpu *vcpu, struct kvm_mmu *mmu, unsigned long cr3); |
| 1263 | 1263 | bool pdptrs_changed(struct kvm_vcpu *vcpu); |
| @@ -1592,4 +1592,7 @@ static inline int kvm_cpu_get_apicid(int mps_cpu) · 328 unmodified lines | ||
| 1592 | 1592 | #define put_smstate(type, buf, offset, val) \ |
| 1593 | 1593 | *(type *)((buf) + (offset) - 0x7e00) = val |
| 1594 | 1594 | |
| 1595 | +#define GET_SMSTATE(type, buf, offset) \ | |
| 1596 | + (*(type *)((buf) + (offset) - 0x7e00)) | |
| 1597 | + | |
| 1595 | 1598 | #endif /* _ASM_X86_KVM_HOST_H */ |
| @@ -146,6 +146,7 @@ · 145 unmodified lines | ||
| 146 | 146 | |
| 147 | 147 | #define VMX_ABORT_SAVE_GUEST_MSR_FAIL 1 |
| 148 | 148 | #define VMX_ABORT_LOAD_HOST_PDPTE_FAIL 2 |
| 149 | +#define VMX_ABORT_VMCS_CORRUPTED 3 | |
| 149 | 150 | #define VMX_ABORT_LOAD_HOST_MSR_FAIL 4 |
| 150 | 151 | |
| 151 | 152 | #endif /* _UAPIVMX_H */ |
| @@ -2039,14 +2039,14 @@ out: · 2038 unmodified lines | ||
| 2039 | 2039 | enum rdt_param { |
| 2040 | 2040 | Opt_cdp, |
| 2041 | 2041 | Opt_cdpl2, |
| 2042 | − Opt_mba_mpbs, | |
| 2042 | + Opt_mba_mbps, | |
| 2043 | 2043 | nr__rdt_params |
| 2044 | 2044 | }; |
| 2045 | 2045 | |
| 2046 | 2046 | static const struct fs_parameter_spec rdt_param_specs[] = { |
| 2047 | 2047 | fsparam_flag("cdp", Opt_cdp), |
| 2048 | 2048 | fsparam_flag("cdpl2", Opt_cdpl2), |
| 2049 | − fsparam_flag("mba_mpbs", Opt_mba_mpbs), | |
| 2049 | + fsparam_flag("mba_MBps", Opt_mba_mbps), | |
| 2050 | 2050 | {} |
| 2051 | 2051 | }; |
| 2052 | 2052 | |
| @@ -2072,7 +2072,7 @@ static int rdt_parse_param(struct fs_context *fc, struct fs_parameter *param) · 19 unmodified lines | ||
| 2072 | 2072 | case Opt_cdpl2: |
| 2073 | 2073 | ctx->enable_cdpl2 = true; |
| 2074 | 2074 | return 0; |
| 2075 | − case Opt_mba_mpbs: | |
| 2075 | + case Opt_mba_mbps: | |
| 2076 | 2076 | if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL) |
| 2077 | 2077 | return -EINVAL; |
| 2078 | 2078 | ctx->enable_mba_mbps = true; |
| @@ -2331,24 +2331,18 @@ static int em_lseg(struct x86_emulate_ctxt *ctxt) · 2330 unmodified lines | ||
| 2331 | 2331 | |
| 2332 | 2332 | static int emulator_has_longmode(struct x86_emulate_ctxt *ctxt) |
| 2333 | 2333 | { |
| 2334 | +#ifdef CONFIG_X86_64 | |
| 2334 | 2335 | u32 eax, ebx, ecx, edx; |
| 2335 | 2336 | |
| 2336 | 2337 | eax = 0x80000001; |
| 2337 | 2338 | ecx = 0; |
| 2338 | 2339 | ctxt->ops->get_cpuid(ctxt, &eax, &ebx, &ecx, &edx, false); |
| 2339 | 2340 | return edx & bit(X86_FEATURE_LM); |
| 2341 | +#else | |
| 2342 | + return false; | |
| 2343 | +#endif | |
| 2340 | 2344 | } |
| 2341 | 2345 | |
| 2342 | −#define GET_SMSTATE(type, smbase, offset) \ | |
| 2343 | − ({ \ | |
| 2344 | − type __val; \ | |
| 2345 | − int r = ctxt->ops->read_phys(ctxt, smbase + offset, &__val, \ | |
| 2346 | − sizeof(__val)); \ | |
| 2347 | − if (r != X86EMUL_CONTINUE) \ | |
| 2348 | − return X86EMUL_UNHANDLEABLE; \ | |
| 2349 | − __val; \ | |
| 2350 | − }) | |
| 2351 | − | |
| 2352 | 2346 | static void rsm_set_desc_flags(struct desc_struct *desc, u32 flags) |
| 2353 | 2347 | { |
| 2354 | 2348 | desc->g = (flags >> 23) & 1; |
| @@ -2361,27 +2355,30 @@ static void rsm_set_desc_flags(struct desc_struct *desc, u32 flags) · 6 unmodified lines | ||
| 2361 | 2355 | desc->type = (flags >> 8) & 15; |
| 2362 | 2356 | } |
| 2363 | 2357 | |
| 2364 | −static int rsm_load_seg_32(struct x86_emulate_ctxt *ctxt, u64 smbase, int n) | |
| 2358 | +static int rsm_load_seg_32(struct x86_emulate_ctxt *ctxt, const char *smstate, | |
| 2359 | + int n) | |
| 2365 | 2360 | { |
| 2366 | 2361 | struct desc_struct desc; |
| 2367 | 2362 | int offset; |
| 2368 | 2363 | u16 selector; |
| 2369 | 2364 | |
| 2370 | − selector = GET_SMSTATE(u32, smbase, 0x7fa8 + n * 4); | |
| 2365 | + selector = GET_SMSTATE(u32, smstate, 0x7fa8 + n * 4); | |
| 2371 | 2366 | |
| 2372 | 2367 | if (n < 3) |
| 2373 | 2368 | offset = 0x7f84 + n * 12; |
| 2374 | 2369 | else |
| 2375 | 2370 | offset = 0x7f2c + (n - 3) * 12; |
| 2376 | 2371 | |
| 2377 | − set_desc_base(&desc, GET_SMSTATE(u32, smbase, offset + 8)); | |
| 2378 | − set_desc_limit(&desc, GET_SMSTATE(u32, smbase, offset + 4)); | |
| 2379 | − rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smbase, offset)); | |
| 2372 | + set_desc_base(&desc, GET_SMSTATE(u32, smstate, offset + 8)); | |
| 2373 | + set_desc_limit(&desc, GET_SMSTATE(u32, smstate, offset + 4)); | |
| 2374 | + rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smstate, offset)); | |
| 2380 | 2375 | ctxt->ops->set_segment(ctxt, selector, &desc, 0, n); |
| 2381 | 2376 | return X86EMUL_CONTINUE; |
| 2382 | 2377 | } |
| 2383 | 2378 | |
| 2384 | −static int rsm_load_seg_64(struct x86_emulate_ctxt *ctxt, u64 smbase, int n) | |
| 2379 | +#ifdef CONFIG_X86_64 | |
| 2380 | +static int rsm_load_seg_64(struct x86_emulate_ctxt *ctxt, const char *smstate, | |
| 2381 | + int n) | |
| 2385 | 2382 | { |
| 2386 | 2383 | struct desc_struct desc; |
| 2387 | 2384 | int offset; |
| @@ -2390,15 +2387,16 @@ static int rsm_load_seg_64(struct x86_emulate_ctxt *ctxt, u64 smbase, int n) · 2 unmodified lines | ||
| 2390 | 2387 | |
| 2391 | 2388 | offset = 0x7e00 + n * 16; |
| 2392 | 2389 | |
| 2393 | − selector = GET_SMSTATE(u16, smbase, offset); | |
| 2394 | − rsm_set_desc_flags(&desc, GET_SMSTATE(u16, smbase, offset + 2) << 8); | |
| 2395 | − set_desc_limit(&desc, GET_SMSTATE(u32, smbase, offset + 4)); | |
| 2396 | − set_desc_base(&desc, GET_SMSTATE(u32, smbase, offset + 8)); | |
| 2397 | − base3 = GET_SMSTATE(u32, smbase, offset + 12); | |
| 2390 | + selector = GET_SMSTATE(u16, smstate, offset); | |
| 2391 | + rsm_set_desc_flags(&desc, GET_SMSTATE(u16, smstate, offset + 2) << 8); | |
| 2392 | + set_desc_limit(&desc, GET_SMSTATE(u32, smstate, offset + 4)); | |
| 2393 | + set_desc_base(&desc, GET_SMSTATE(u32, smstate, offset + 8)); | |
| 2394 | + base3 = GET_SMSTATE(u32, smstate, offset + 12); | |
| 2398 | 2395 | |
| 2399 | 2396 | ctxt->ops->set_segment(ctxt, selector, &desc, base3, n); |
| 2400 | 2397 | return X86EMUL_CONTINUE; |
| 2401 | 2398 | } |
| 2399 | +#endif | |
| 2402 | 2400 | |
| 2403 | 2401 | static int rsm_enter_protected_mode(struct x86_emulate_ctxt *ctxt, |
| 2404 | 2402 | u64 cr0, u64 cr3, u64 cr4) |
| @@ -2445,7 +2443,8 @@ static int rsm_enter_protected_mode(struct x86_emulate_ctxt *ctxt, · 40 unmodified lines | ||
| 2445 | 2443 | return X86EMUL_CONTINUE; |
| 2446 | 2444 | } |
| 2447 | 2445 | |
| 2448 | −static int rsm_load_state_32(struct x86_emulate_ctxt *ctxt, u64 smbase) | |
| 2446 | +static int rsm_load_state_32(struct x86_emulate_ctxt *ctxt, | |
| 2447 | + const char *smstate) | |
| 2449 | 2448 | { |
| 2450 | 2449 | struct desc_struct desc; |
| 2451 | 2450 | struct desc_ptr dt; |
| @@ -2453,53 +2452,55 @@ static int rsm_load_state_32(struct x86_emulate_ctxt *ctxt, u64 smbase) · 1 unmodified line | ||
| 2453 | 2452 | u32 val, cr0, cr3, cr4; |
| 2454 | 2453 | int i; |
| 2455 | 2454 | |
| 2456 | − cr0 = GET_SMSTATE(u32, smbase, 0x7ffc); | |
| 2457 | − cr3 = GET_SMSTATE(u32, smbase, 0x7ff8); | |
| 2458 | − ctxt->eflags = GET_SMSTATE(u32, smbase, 0x7ff4) | X86_EFLAGS_FIXED; | |
| 2459 | − ctxt->_eip = GET_SMSTATE(u32, smbase, 0x7ff0); | |
| 2455 | + cr0 = GET_SMSTATE(u32, smstate, 0x7ffc); | |
| 2456 | + cr3 = GET_SMSTATE(u32, smstate, 0x7ff8); | |
| 2457 | + ctxt->eflags = GET_SMSTATE(u32, smstate, 0x7ff4) | X86_EFLAGS_FIXED; | |
| 2458 | + ctxt->_eip = GET_SMSTATE(u32, smstate, 0x7ff0); | |
| 2460 | 2459 | |
| 2461 | 2460 | for (i = 0; i < 8; i++) |
| 2462 | − *reg_write(ctxt, i) = GET_SMSTATE(u32, smbase, 0x7fd0 + i * 4); | |
| 2461 | + *reg_write(ctxt, i) = GET_SMSTATE(u32, smstate, 0x7fd0 + i * 4); | |
| 2463 | 2462 | |
| 2464 | − val = GET_SMSTATE(u32, smbase, 0x7fcc); | |
| 2463 | + val = GET_SMSTATE(u32, smstate, 0x7fcc); | |
| 2465 | 2464 | ctxt->ops->set_dr(ctxt, 6, (val & DR6_VOLATILE) | DR6_FIXED_1); |
| 2466 | − val = GET_SMSTATE(u32, smbase, 0x7fc8); | |
| 2465 | + val = GET_SMSTATE(u32, smstate, 0x7fc8); | |
| 2467 | 2466 | ctxt->ops->set_dr(ctxt, 7, (val & DR7_VOLATILE) | DR7_FIXED_1); |
| 2468 | 2467 | |
| 2469 | − selector = GET_SMSTATE(u32, smbase, 0x7fc4); | |
| 2470 | − set_desc_base(&desc, GET_SMSTATE(u32, smbase, 0x7f64)); | |
| 2471 | − set_desc_limit(&desc, GET_SMSTATE(u32, smbase, 0x7f60)); | |
| 2472 | − rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smbase, 0x7f5c)); | |
| 2468 | + selector = GET_SMSTATE(u32, smstate, 0x7fc4); | |
| 2469 | + set_desc_base(&desc, GET_SMSTATE(u32, smstate, 0x7f64)); | |
| 2470 | + set_desc_limit(&desc, GET_SMSTATE(u32, smstate, 0x7f60)); | |
| 2471 | + rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smstate, 0x7f5c)); | |
| 2473 | 2472 | ctxt->ops->set_segment(ctxt, selector, &desc, 0, VCPU_SREG_TR); |
| 2474 | 2473 | |
| 2475 | − selector = GET_SMSTATE(u32, smbase, 0x7fc0); | |
| 2476 | − set_desc_base(&desc, GET_SMSTATE(u32, smbase, 0x7f80)); | |
| 2477 | − set_desc_limit(&desc, GET_SMSTATE(u32, smbase, 0x7f7c)); | |
| 2478 | − rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smbase, 0x7f78)); | |
| 2474 | + selector = GET_SMSTATE(u32, smstate, 0x7fc0); | |
| 2475 | + set_desc_base(&desc, GET_SMSTATE(u32, smstate, 0x7f80)); | |
| 2476 | + set_desc_limit(&desc, GET_SMSTATE(u32, smstate, 0x7f7c)); | |
| 2477 | + rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smstate, 0x7f78)); | |
| 2479 | 2478 | ctxt->ops->set_segment(ctxt, selector, &desc, 0, VCPU_SREG_LDTR); |
| 2480 | 2479 | |
| 2481 | − dt.address = GET_SMSTATE(u32, smbase, 0x7f74); | |
| 2482 | − dt.size = GET_SMSTATE(u32, smbase, 0x7f70); | |
| 2480 | + dt.address = GET_SMSTATE(u32, smstate, 0x7f74); | |
| 2481 | + dt.size = GET_SMSTATE(u32, smstate, 0x7f70); | |
| 2483 | 2482 | ctxt->ops->set_gdt(ctxt, &dt); |
| 2484 | 2483 | |
| 2485 | − dt.address = GET_SMSTATE(u32, smbase, 0x7f58); | |
| 2486 | − dt.size = GET_SMSTATE(u32, smbase, 0x7f54); | |
| 2484 | + dt.address = GET_SMSTATE(u32, smstate, 0x7f58); | |
| 2485 | + dt.size = GET_SMSTATE(u32, smstate, 0x7f54); | |
| 2487 | 2486 | ctxt->ops->set_idt(ctxt, &dt); |
| 2488 | 2487 | |
| 2489 | 2488 | for (i = 0; i < 6; i++) { |
| 2490 | − int r = rsm_load_seg_32(ctxt, smbase, i); | |
| 2489 | + int r = rsm_load_seg_32(ctxt, smstate, i); | |
| 2491 | 2490 | if (r != X86EMUL_CONTINUE) |
| 2492 | 2491 | return r; |
| 2493 | 2492 | } |
| 2494 | 2493 | |
| 2495 | − cr4 = GET_SMSTATE(u32, smbase, 0x7f14); | |
| 2494 | + cr4 = GET_SMSTATE(u32, smstate, 0x7f14); | |
| 2496 | 2495 | |
| 2497 | − ctxt->ops->set_smbase(ctxt, GET_SMSTATE(u32, smbase, 0x7ef8)); | |
| 2496 | + ctxt->ops->set_smbase(ctxt, GET_SMSTATE(u32, smstate, 0x7ef8)); | |
| 2498 | 2497 | |
| 2499 | 2498 | return rsm_enter_protected_mode(ctxt, cr0, cr3, cr4); |
| 2500 | 2499 | } |
| 2501 | 2500 | |
| 2502 | −static int rsm_load_state_64(struct x86_emulate_ctxt *ctxt, u64 smbase) | |
| 2501 | +#ifdef CONFIG_X86_64 | |
| 2502 | +static int rsm_load_state_64(struct x86_emulate_ctxt *ctxt, | |
| 2503 | + const char *smstate) | |
| 2503 | 2504 | { |
| 2504 | 2505 | struct desc_struct desc; |
| 2505 | 2506 | struct desc_ptr dt; |
| @@ -2509,43 +2510,43 @@ static int rsm_load_state_64(struct x86_emulate_ctxt *ctxt, u64 smbase) · 3 unmodified lines | ||
| 2509 | 2510 | int i, r; |
| 2510 | 2511 | |
| 2511 | 2512 | for (i = 0; i < 16; i++) |
| 2512 | − *reg_write(ctxt, i) = GET_SMSTATE(u64, smbase, 0x7ff8 - i * 8); | |
| 2513 | + *reg_write(ctxt, i) = GET_SMSTATE(u64, smstate, 0x7ff8 - i * 8); | |
| 2513 | 2514 | |
| 2514 | − ctxt->_eip = GET_SMSTATE(u64, smbase, 0x7f78); | |
| 2515 | − ctxt->eflags = GET_SMSTATE(u32, smbase, 0x7f70) | X86_EFLAGS_FIXED; | |
| 2515 | + ctxt->_eip = GET_SMSTATE(u64, smstate, 0x7f78); | |
| 2516 | + ctxt->eflags = GET_SMSTATE(u32, smstate, 0x7f70) | X86_EFLAGS_FIXED; | |
| 2516 | 2517 | |
| 2517 | − val = GET_SMSTATE(u32, smbase, 0x7f68); | |
| 2518 | + val = GET_SMSTATE(u32, smstate, 0x7f68); | |
| 2518 | 2519 | ctxt->ops->set_dr(ctxt, 6, (val & DR6_VOLATILE) | DR6_FIXED_1); |
| 2519 | − val = GET_SMSTATE(u32, smbase, 0x7f60); | |
| 2520 | + val = GET_SMSTATE(u32, smstate, 0x7f60); | |
| 2520 | 2521 | ctxt->ops->set_dr(ctxt, 7, (val & DR7_VOLATILE) | DR7_FIXED_1); |
| 2521 | 2522 | |
| 2522 | − cr0 = GET_SMSTATE(u64, smbase, 0x7f58); | |
| 2523 | − cr3 = GET_SMSTATE(u64, smbase, 0x7f50); | |
| 2524 | − cr4 = GET_SMSTATE(u64, smbase, 0x7f48); | |
| 2525 | − ctxt->ops->set_smbase(ctxt, GET_SMSTATE(u32, smbase, 0x7f00)); | |
| 2526 | − val = GET_SMSTATE(u64, smbase, 0x7ed0); | |
| 2523 | + cr0 = GET_SMSTATE(u64, smstate, 0x7f58); | |
| 2524 | + cr3 = GET_SMSTATE(u64, smstate, 0x7f50); | |
| 2525 | + cr4 = GET_SMSTATE(u64, smstate, 0x7f48); | |
| 2526 | + ctxt->ops->set_smbase(ctxt, GET_SMSTATE(u32, smstate, 0x7f00)); | |
| 2527 | + val = GET_SMSTATE(u64, smstate, 0x7ed0); | |
| 2527 | 2528 | ctxt->ops->set_msr(ctxt, MSR_EFER, val & ~EFER_LMA); |
| 2528 | 2529 | |
| 2529 | − selector = GET_SMSTATE(u32, smbase, 0x7e90); | |
| 2530 | − rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smbase, 0x7e92) << 8); | |
| 2531 | − set_desc_limit(&desc, GET_SMSTATE(u32, smbase, 0x7e94)); | |
| 2532 | − set_desc_base(&desc, GET_SMSTATE(u32, smbase, 0x7e98)); | |
| 2533 | − base3 = GET_SMSTATE(u32, smbase, 0x7e9c); | |
| 2530 | + selector = GET_SMSTATE(u32, smstate, 0x7e90); | |
| 2531 | + rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smstate, 0x7e92) << 8); | |
| 2532 | + set_desc_limit(&desc, GET_SMSTATE(u32, smstate, 0x7e94)); | |
| 2533 | + set_desc_base(&desc, GET_SMSTATE(u32, smstate, 0x7e98)); | |
| 2534 | + base3 = GET_SMSTATE(u32, smstate, 0x7e9c); | |
| 2534 | 2535 | ctxt->ops->set_segment(ctxt, selector, &desc, base3, VCPU_SREG_TR); |
| 2535 | 2536 | |
| 2536 | − dt.size = GET_SMSTATE(u32, smbase, 0x7e84); | |
| 2537 | − dt.address = GET_SMSTATE(u64, smbase, 0x7e88); | |
| 2537 | + dt.size = GET_SMSTATE(u32, smstate, 0x7e84); | |
| 2538 | + dt.address = GET_SMSTATE(u64, smstate, 0x7e88); | |
| 2538 | 2539 | ctxt->ops->set_idt(ctxt, &dt); |
| 2539 | 2540 | |
| 2540 | − selector = GET_SMSTATE(u32, smbase, 0x7e70); | |
| 2541 | − rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smbase, 0x7e72) << 8); | |
| 2542 | − set_desc_limit(&desc, GET_SMSTATE(u32, smbase, 0x7e74)); | |
| 2543 | − set_desc_base(&desc, GET_SMSTATE(u32, smbase, 0x7e78)); | |
| 2544 | − base3 = GET_SMSTATE(u32, smbase, 0x7e7c); | |
| 2541 | + selector = GET_SMSTATE(u32, smstate, 0x7e70); | |
| 2542 | + rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smstate, 0x7e72) << 8); | |
| 2543 | + set_desc_limit(&desc, GET_SMSTATE(u32, smstate, 0x7e74)); | |
| 2544 | + set_desc_base(&desc, GET_SMSTATE(u32, smstate, 0x7e78)); | |
| 2545 | + base3 = GET_SMSTATE(u32, smstate, 0x7e7c); | |
| 2545 | 2546 | ctxt->ops->set_segment(ctxt, selector, &desc, base3, VCPU_SREG_LDTR); |
| 2546 | 2547 | |
| 2547 | − dt.size = GET_SMSTATE(u32, smbase, 0x7e64); | |
| 2548 | − dt.address = GET_SMSTATE(u64, smbase, 0x7e68); | |
| 2548 | + dt.size = GET_SMSTATE(u32, smstate, 0x7e64); | |
| 2549 | + dt.address = GET_SMSTATE(u64, smstate, 0x7e68); | |
| 2549 | 2550 | ctxt->ops->set_gdt(ctxt, &dt); |
| 2550 | 2551 | |
| 2551 | 2552 | r = rsm_enter_protected_mode(ctxt, cr0, cr3, cr4); |
| @@ -2553,37 +2554,49 @@ static int rsm_load_state_64(struct x86_emulate_ctxt *ctxt, u64 smbase) · 1 unmodified line | ||
| 2553 | 2554 | return r; |
| 2554 | 2555 | |
| 2555 | 2556 | for (i = 0; i < 6; i++) { |
| 2556 | − r = rsm_load_seg_64(ctxt, smbase, i); | |
| 2557 | + r = rsm_load_seg_64(ctxt, smstate, i); | |
| 2557 | 2558 | if (r != X86EMUL_CONTINUE) |
| 2558 | 2559 | return r; |
| 2559 | 2560 | } |
| 2560 | 2561 | |
| 2561 | 2562 | return X86EMUL_CONTINUE; |
| 2562 | 2563 | } |
| 2564 | +#endif | |
| 2563 | 2565 | |
| 2564 | 2566 | static int em_rsm(struct x86_emulate_ctxt *ctxt) |
| 2565 | 2567 | { |
| 2566 | 2568 | unsigned long cr0, cr4, efer; |
| 2569 | + char buf[512]; | |
| 2567 | 2570 | u64 smbase; |
| 2568 | 2571 | int ret; |
| 2569 | 2572 | |
| 2570 | 2573 | if ((ctxt->ops->get_hflags(ctxt) & X86EMUL_SMM_MASK) == 0) |
| 2571 | 2574 | return emulate_ud(ctxt); |
| 2572 | 2575 | |
| 2576 | + smbase = ctxt->ops->get_smbase(ctxt); | |
| 2577 | + | |
| 2578 | + ret = ctxt->ops->read_phys(ctxt, smbase + 0xfe00, buf, sizeof(buf)); | |
| 2579 | + if (ret != X86EMUL_CONTINUE) | |
| 2580 | + return X86EMUL_UNHANDLEABLE; | |
| 2581 | + | |
| 2582 | + if ((ctxt->ops->get_hflags(ctxt) & X86EMUL_SMM_INSIDE_NMI_MASK) == 0) | |
| 2583 | + ctxt->ops->set_nmi_mask(ctxt, false); | |
| 2584 | + | |
| 2585 | + ctxt->ops->set_hflags(ctxt, ctxt->ops->get_hflags(ctxt) & | |
| 2586 | + ~(X86EMUL_SMM_INSIDE_NMI_MASK | X86EMUL_SMM_MASK)); | |
| 2587 | + | |
| 2573 | 2588 | /* |
| 2574 | 2589 | * Get back to real mode, to prepare a safe state in which to load |
| 2575 | 2590 | * CR0/CR3/CR4/EFER. It's all a bit more complicated if the vCPU |
| 2576 | 2591 | * supports long mode. |
| 2577 | 2592 | */ |
| 2578 | − cr4 = ctxt->ops->get_cr(ctxt, 4); | |
| 2579 | 2593 | if (emulator_has_longmode(ctxt)) { |
| 2580 | 2594 | struct desc_struct cs_desc; |
| 2581 | 2595 | |
| 2582 | 2596 | /* Zero CR4.PCIDE before CR0.PG. */ |
| 2583 | − if (cr4 & X86_CR4_PCIDE) { | |
| 2597 | + cr4 = ctxt->ops->get_cr(ctxt, 4); | |
| 2598 | + if (cr4 & X86_CR4_PCIDE) | |
| 2584 | 2599 | ctxt->ops->set_cr(ctxt, 4, cr4 & ~X86_CR4_PCIDE); |
| 2585 | − cr4 &= ~X86_CR4_PCIDE; | |
| 2586 | − } | |
| 2587 | 2600 | |
| 2588 | 2601 | /* A 32-bit code segment is required to clear EFER.LMA. */ |
| 2589 | 2602 | memset(&cs_desc, 0, sizeof(cs_desc)); |
| @@ -2597,39 +2610,39 @@ static int em_rsm(struct x86_emulate_ctxt *ctxt) · 7 unmodified lines | ||
| 2597 | 2610 | if (cr0 & X86_CR0_PE) |
| 2598 | 2611 | ctxt->ops->set_cr(ctxt, 0, cr0 & ~(X86_CR0_PG | X86_CR0_PE)); |
| 2599 | 2612 | |
| 2600 | − /* Now clear CR4.PAE (which must be done before clearing EFER.LME). */ | |
| 2601 | − if (cr4 & X86_CR4_PAE) | |
| 2602 | − ctxt->ops->set_cr(ctxt, 4, cr4 & ~X86_CR4_PAE); | |
| 2603 | − | |
| 2604 | − /* And finally go back to 32-bit mode. */ | |
| 2605 | − efer = 0; | |
| 2606 | − ctxt->ops->set_msr(ctxt, MSR_EFER, efer); | |
| 2613 | + if (emulator_has_longmode(ctxt)) { | |
| 2614 | + /* Clear CR4.PAE before clearing EFER.LME. */ | |
| 2615 | + cr4 = ctxt->ops->get_cr(ctxt, 4); | |
| 2616 | + if (cr4 & X86_CR4_PAE) | |
| 2617 | + ctxt->ops->set_cr(ctxt, 4, cr4 & ~X86_CR4_PAE); | |
| 2607 | 2618 | |
| 2608 | − smbase = ctxt->ops->get_smbase(ctxt); | |
| 2619 | + /* And finally go back to 32-bit mode. */ | |
| 2620 | + efer = 0; | |
| 2621 | + ctxt->ops->set_msr(ctxt, MSR_EFER, efer); | |
| 2622 | + } | |
| 2609 | 2623 | |
| 2610 | 2624 | /* |
| 2611 | 2625 | * Give pre_leave_smm() a chance to make ISA-specific changes to the |
| 2612 | 2626 | * vCPU state (e.g. enter guest mode) before loading state from the SMM |
| 2613 | 2627 | * state-save area. |
| 2614 | 2628 | */ |
| 2615 | − if (ctxt->ops->pre_leave_smm(ctxt, smbase)) | |
| 2629 | + if (ctxt->ops->pre_leave_smm(ctxt, buf)) | |
| 2616 | 2630 | return X86EMUL_UNHANDLEABLE; |
| 2617 | 2631 | |
| 2632 | +#ifdef CONFIG_X86_64 | |
| 2618 | 2633 | if (emulator_has_longmode(ctxt)) |
| 2619 | − ret = rsm_load_state_64(ctxt, smbase + 0x8000); | |
| 2634 | + ret = rsm_load_state_64(ctxt, buf); | |
| 2620 | 2635 | else |
| 2621 | − ret = rsm_load_state_32(ctxt, smbase + 0x8000); | |
| 2636 | +#endif | |
| 2637 | + ret = rsm_load_state_32(ctxt, buf); | |
| 2622 | 2638 | |
| 2623 | 2639 | if (ret != X86EMUL_CONTINUE) { |
| 2624 | 2640 | /* FIXME: should triple fault */ |
| 2625 | 2641 | return X86EMUL_UNHANDLEABLE; |
| 2626 | 2642 | } |
| 2627 | 2643 | |
| 2628 | − if ((ctxt->ops->get_hflags(ctxt) & X86EMUL_SMM_INSIDE_NMI_MASK) == 0) | |
| 2629 | − ctxt->ops->set_nmi_mask(ctxt, false); | |
| 2644 | + ctxt->ops->post_leave_smm(ctxt); | |
| 2630 | 2645 | |
| 2631 | − ctxt->ops->set_hflags(ctxt, ctxt->ops->get_hflags(ctxt) & | |
| 2632 | − ~(X86EMUL_SMM_INSIDE_NMI_MASK | X86EMUL_SMM_MASK)); | |
| 2633 | 2646 | return X86EMUL_CONTINUE; |
| 2634 | 2647 | } |
| 2635 | 2648 | |
| @@ -138,6 +138,7 @@ static inline bool kvm_apic_map_get_logical_dest(struct kvm_apic_map *map, · 137 unmodified lines | ||
| 138 | 138 | if (offset <= max_apic_id) { |
| 139 | 139 | u8 cluster_size = min(max_apic_id - offset + 1, 16U); |
| 140 | 140 | |
| 141 | + offset = array_index_nospec(offset, map->max_apic_id + 1); | |
| 141 | 142 | *cluster = &map->phys_map[offset]; |
| 142 | 143 | *mask = dest_id & (0xffff >> (16 - cluster_size)); |
| 143 | 144 | } else { |
| @@ -901,7 +902,8 @@ static inline bool kvm_apic_map_get_dest_lapic(struct kvm *kvm, · 757 unmodified lines | ||
| 901 | 902 | if (irq->dest_id > map->max_apic_id) { |
| 902 | 903 | *bitmap = 0; |
| 903 | 904 | } else { |
| 904 | − *dst = &map->phys_map[irq->dest_id]; | |
| 905 | + u32 dest_id = array_index_nospec(irq->dest_id, map->max_apic_id + 1); | |
| 906 | + *dst = &map->phys_map[dest_id]; | |
| 905 | 907 | *bitmap = 1; |
| 906 | 908 | } |
| 907 | 909 | return true; |
| @@ -2007,7 +2007,7 @@ static int is_empty_shadow_page(u64 *spt) · 2006 unmodified lines | ||
| 2007 | 2007 | * aggregate version in order to make the slab shrinker |
| 2008 | 2008 | * faster |
| 2009 | 2009 | */ |
| 2010 | −static inline void kvm_mod_used_mmu_pages(struct kvm *kvm, int nr) | |
| 2010 | +static inline void kvm_mod_used_mmu_pages(struct kvm *kvm, unsigned long nr) | |
| 2011 | 2011 | { |
| 2012 | 2012 | kvm->arch.n_used_mmu_pages += nr; |
| 2013 | 2013 | percpu_counter_add(&kvm_total_used_mmu_pages, nr); |
| @@ -2238,7 +2238,7 @@ static bool kvm_mmu_remote_flush_or_zap(struct kvm *kvm, · 224 unmodified lines | ||
| 2238 | 2238 | struct list_head *invalid_list, |
| 2239 | 2239 | bool remote_flush) |
| 2240 | 2240 | { |
| 2241 | − if (!remote_flush && !list_empty(invalid_list)) | |
| 2241 | + if (!remote_flush && list_empty(invalid_list)) | |
| 2242 | 2242 | return false; |
| 2243 | 2243 | |
| 2244 | 2244 | if (!list_empty(invalid_list)) |
| @@ -2763,7 +2763,7 @@ static bool prepare_zap_oldest_mmu_page(struct kvm *kvm, · 518 unmodified lines | ||
| 2763 | 2763 | * Changing the number of mmu pages allocated to the vm |
| 2764 | 2764 | * Note: if goal_nr_mmu_pages is too small, you will get dead lock |
| 2765 | 2765 | */ |
| 2766 | −void kvm_mmu_change_mmu_pages(struct kvm *kvm, unsigned int goal_nr_mmu_pages) | |
| 2766 | +void kvm_mmu_change_mmu_pages(struct kvm *kvm, unsigned long goal_nr_mmu_pages) | |
| 2767 | 2767 | { |
| 2768 | 2768 | LIST_HEAD(invalid_list); |
| 2769 | 2769 | |
| @@ -6031,10 +6031,10 @@ out: · 3261 unmodified lines | ||
| 6031 | 6031 | /* |
| 6032 | 6032 | * Calculate mmu pages needed for kvm. |
| 6033 | 6033 | */ |
| 6034 | −unsigned int kvm_mmu_calculate_default_mmu_pages(struct kvm *kvm) | |
| 6034 | +unsigned long kvm_mmu_calculate_default_mmu_pages(struct kvm *kvm) | |
| 6035 | 6035 | { |
| 6036 | − unsigned int nr_mmu_pages; | |
| 6037 | − unsigned int nr_pages = 0; | |
| 6036 | + unsigned long nr_mmu_pages; | |
| 6037 | + unsigned long nr_pages = 0; | |
| 6038 | 6038 | struct kvm_memslots *slots; |
| 6039 | 6039 | struct kvm_memory_slot *memslot; |
| 6040 | 6040 | int i; |
| @@ -6047,8 +6047,7 @@ unsigned int kvm_mmu_calculate_default_mmu_pages(struct kvm *kvm) · 6 unmodified lines | ||
| 6047 | 6047 | } |
| 6048 | 6048 | |
| 6049 | 6049 | nr_mmu_pages = nr_pages * KVM_PERMILLE_MMU_PAGES / 1000; |
| 6050 | − nr_mmu_pages = max(nr_mmu_pages, | |
| 6051 | − (unsigned int) KVM_MIN_ALLOC_MMU_PAGES); | |
| 6050 | + nr_mmu_pages = max(nr_mmu_pages, KVM_MIN_ALLOC_MMU_PAGES); | |
| 6052 | 6051 | |
| 6053 | 6052 | return nr_mmu_pages; |
| 6054 | 6053 | } |
| @@ -64,7 +64,7 @@ bool kvm_can_do_async_pf(struct kvm_vcpu *vcpu); · 63 unmodified lines | ||
| 64 | 64 | int kvm_handle_page_fault(struct kvm_vcpu *vcpu, u64 error_code, |
| 65 | 65 | u64 fault_address, char *insn, int insn_len); |
| 66 | 66 | |
| 67 | −static inline unsigned int kvm_mmu_available_pages(struct kvm *kvm) | |
| 67 | +static inline unsigned long kvm_mmu_available_pages(struct kvm *kvm) | |
| 68 | 68 | { |
| 69 | 69 | if (kvm->arch.n_max_mmu_pages > kvm->arch.n_used_mmu_pages) |
| 70 | 70 | return kvm->arch.n_max_mmu_pages - |
| @@ -281,9 +281,13 @@ static int kvm_pmu_rdpmc_vmware(struct kvm_vcpu *vcpu, unsigned idx, u64 *data) · 280 unmodified lines | ||
| 281 | 281 | int kvm_pmu_rdpmc(struct kvm_vcpu *vcpu, unsigned idx, u64 *data) |
| 282 | 282 | { |
| 283 | 283 | bool fast_mode = idx & (1u << 31); |
| 284 | + struct kvm_pmu *pmu = vcpu_to_pmu(vcpu); | |
| 284 | 285 | struct kvm_pmc *pmc; |
| 285 | 286 | u64 ctr_val; |
| 286 | 287 | |
| 288 | + if (!pmu->version) | |
| 289 | + return 1; | |
| 290 | + | |
| 287 | 291 | if (is_vmware_backdoor_pmc(idx)) |
| 288 | 292 | return kvm_pmu_rdpmc_vmware(vcpu, idx, data); |
| 289 | 293 | |
| @@ -262,6 +262,7 @@ struct amd_svm_iommu_ir { · 261 unmodified lines | ||
| 262 | 262 | }; |
| 263 | 263 | |
| 264 | 264 | #define AVIC_LOGICAL_ID_ENTRY_GUEST_PHYSICAL_ID_MASK (0xFF) |
| 265 | +#define AVIC_LOGICAL_ID_ENTRY_VALID_BIT 31 | |
| 265 | 266 | #define AVIC_LOGICAL_ID_ENTRY_VALID_MASK (1 << 31) |
| 266 | 267 | |
| 267 | 268 | #define AVIC_PHYSICAL_ID_ENTRY_HOST_PHYSICAL_ID_MASK (0xFFULL) |
| @@ -2692,6 +2693,7 @@ static int npf_interception(struct vcpu_svm *svm) · 2424 unmodified lines | ||
| 2692 | 2693 | static int db_interception(struct vcpu_svm *svm) |
| 2693 | 2694 | { |
| 2694 | 2695 | struct kvm_run *kvm_run = svm->vcpu.run; |
| 2696 | + struct kvm_vcpu *vcpu = &svm->vcpu; | |
| 2695 | 2697 | |
| 2696 | 2698 | if (!(svm->vcpu.guest_debug & |
| 2697 | 2699 | (KVM_GUESTDBG_SINGLESTEP | KVM_GUESTDBG_USE_HW_BP)) && |
| @@ -2702,6 +2704,8 @@ static int db_interception(struct vcpu_svm *svm) · 4 unmodified lines | ||
| 2702 | 2704 | |
| 2703 | 2705 | if (svm->nmi_singlestep) { |
| 2704 | 2706 | disable_nmi_singlestep(svm); |
| 2707 | + /* Make sure we check for pending NMIs upon entry */ | |
| 2708 | + kvm_make_request(KVM_REQ_EVENT, vcpu); | |
| 2705 | 2709 | } |
| 2706 | 2710 | |
| 2707 | 2711 | if (svm->vcpu.guest_debug & |
| @@ -4517,14 +4521,25 @@ static int avic_incomplete_ipi_interception(struct vcpu_svm *svm) · 1809 unmodified lines | ||
| 4517 | 4521 | kvm_lapic_reg_write(apic, APIC_ICR, icrl); |
| 4518 | 4522 | break; |
| 4519 | 4523 | case AVIC_IPI_FAILURE_TARGET_NOT_RUNNING: { |
| 4524 | + int i; | |
| 4525 | + struct kvm_vcpu *vcpu; | |
| 4526 | + struct kvm *kvm = svm->vcpu.kvm; | |
| 4520 | 4527 | struct kvm_lapic *apic = svm->vcpu.arch.apic; |
| 4521 | 4528 | |
| 4522 | 4529 | /* |
| 4523 | − * Update ICR high and low, then emulate sending IPI, | |
| 4524 | − * which is handled when writing APIC_ICR. | |
| 4530 | + * At this point, we expect that the AVIC HW has already | |
| 4531 | + * set the appropriate IRR bits on the valid target | |
| 4532 | + * vcpus. So, we just need to kick the appropriate vcpu. | |
| 4525 | 4533 | */ |
| 4526 | − kvm_lapic_reg_write(apic, APIC_ICR2, icrh); | |
| 4527 | − kvm_lapic_reg_write(apic, APIC_ICR, icrl); | |
| 4534 | + kvm_for_each_vcpu(i, vcpu, kvm) { | |
| 4535 | + bool m = kvm_apic_match_dest(vcpu, apic, | |
| 4536 | + icrl & KVM_APIC_SHORT_MASK, | |
| 4537 | + GET_APIC_DEST_FIELD(icrh), | |
| 4538 | + icrl & KVM_APIC_DEST_MASK); | |
| 4539 | + | |
| 4540 | + if (m && !avic_vcpu_is_running(vcpu)) | |
| 4541 | + kvm_vcpu_wake_up(vcpu); | |
| 4542 | + } | |
| 4528 | 4543 | break; |
| 4529 | 4544 | } |
| 4530 | 4545 | case AVIC_IPI_FAILURE_INVALID_TARGET: |
| @@ -4596,7 +4611,7 @@ static void avic_invalidate_logical_id_entry(struct kvm_vcpu *vcpu) · 65 unmodified lines | ||
| 4596 | 4611 | u32 *entry = avic_get_logical_id_entry(vcpu, svm->ldr_reg, flat); |
| 4597 | 4612 | |
| 4598 | 4613 | if (entry) |
| 4599 | − WRITE_ONCE(*entry, (u32) ~AVIC_LOGICAL_ID_ENTRY_VALID_MASK); | |
| 4614 | + clear_bit(AVIC_LOGICAL_ID_ENTRY_VALID_BIT, (unsigned long *)entry); | |
| 4600 | 4615 | } |
| 4601 | 4616 | |
| 4602 | 4617 | static int avic_handle_ldr_update(struct kvm_vcpu *vcpu) |
| @@ -5621,6 +5636,7 @@ static void svm_vcpu_run(struct kvm_vcpu *vcpu) · 1018 unmodified lines | ||
| 5621 | 5636 | svm->vmcb->save.cr2 = vcpu->arch.cr2; |
| 5622 | 5637 | |
| 5623 | 5638 | clgi(); |
| 5639 | + kvm_load_guest_xcr0(vcpu); | |
| 5624 | 5640 | |
| 5625 | 5641 | /* |
| 5626 | 5642 | * If this vCPU has touched SPEC_CTRL, restore the guest's value if |
| @@ -5766,6 +5782,7 @@ static void svm_vcpu_run(struct kvm_vcpu *vcpu) · 139 unmodified lines | ||
| 5766 | 5782 | if (unlikely(svm->vmcb->control.exit_code == SVM_EXIT_NMI)) |
| 5767 | 5783 | kvm_before_interrupt(&svm->vcpu); |
| 5768 | 5784 | |
| 5785 | + kvm_put_guest_xcr0(vcpu); | |
| 5769 | 5786 | stgi(); |
| 5770 | 5787 | |
| 5771 | 5788 | /* Any pending NMI will happen here */ |
| @@ -6215,32 +6232,24 @@ static int svm_pre_enter_smm(struct kvm_vcpu *vcpu, char *smstate) · 443 unmodified lines | ||
| 6215 | 6232 | return 0; |
| 6216 | 6233 | } |
| 6217 | 6234 | |
| 6218 | −static int svm_pre_leave_smm(struct kvm_vcpu *vcpu, u64 smbase) | |
| 6235 | +static int svm_pre_leave_smm(struct kvm_vcpu *vcpu, const char *smstate) | |
| 6219 | 6236 | { |
| 6220 | 6237 | struct vcpu_svm *svm = to_svm(vcpu); |
| 6221 | 6238 | struct vmcb *nested_vmcb; |
| 6222 | 6239 | struct page *page; |
| 6223 | − struct { | |
| 6224 | − u64 guest; | |
| 6225 | − u64 vmcb; | |
| 6226 | − } svm_state_save; | |
| 6227 | − int ret; | |
| 6240 | + u64 guest; | |
| 6241 | + u64 vmcb; | |
| 6228 | 6242 | |
| 6229 | − ret = kvm_vcpu_read_guest(vcpu, smbase + 0xfed8, &svm_state_save, | |
| 6230 | − sizeof(svm_state_save)); | |
| 6231 | − if (ret) | |
| 6232 | − return ret; | |
| 6243 | + guest = GET_SMSTATE(u64, smstate, 0x7ed8); | |
| 6244 | + vmcb = GET_SMSTATE(u64, smstate, 0x7ee0); | |
| 6233 | 6245 | |
| 6234 | − if (svm_state_save.guest) { | |
| 6235 | − vcpu->arch.hflags &= ~HF_SMM_MASK; | |
| 6236 | − nested_vmcb = nested_svm_map(svm, svm_state_save.vmcb, &page); | |
| 6237 | − if (nested_vmcb) | |
| 6238 | − enter_svm_guest_mode(svm, svm_state_save.vmcb, nested_vmcb, page); | |
| 6239 | − else | |
| 6240 | − ret = 1; | |
| 6241 | − vcpu->arch.hflags |= HF_SMM_MASK; | |
| 6246 | + if (guest) { | |
| 6247 | + nested_vmcb = nested_svm_map(svm, vmcb, &page); | |
| 6248 | + if (!nested_vmcb) | |
| 6249 | + return 1; | |
| 6250 | + enter_svm_guest_mode(svm, vmcb, nested_vmcb, page); | |
| 6242 | 6251 | } |
| 6243 | − return ret; | |
| 6252 | + return 0; | |
| 6244 | 6253 | } |
| 6245 | 6254 | |
| 6246 | 6255 | static int enable_smi_window(struct kvm_vcpu *vcpu) |
| @@ -438,13 +438,13 @@ TRACE_EVENT(kvm_apic_ipi, · 437 unmodified lines | ||
| 438 | 438 | ); |
| 439 | 439 | |
| 440 | 440 | TRACE_EVENT(kvm_apic_accept_irq, |
| 441 | − TP_PROTO(__u32 apicid, __u16 dm, __u8 tm, __u8 vec), | |
| 441 | + TP_PROTO(__u32 apicid, __u16 dm, __u16 tm, __u8 vec), | |
| 442 | 442 | TP_ARGS(apicid, dm, tm, vec), |
| 443 | 443 | |
| 444 | 444 | TP_STRUCT__entry( |
| 445 | 445 | __field( __u32, apicid ) |
| 446 | 446 | __field( __u16, dm ) |
| 447 | − __field( __u8, tm ) | |
| 447 | + __field( __u16, tm ) | |
| 448 | 448 | __field( __u8, vec ) |
| 449 | 449 | ), |
| 450 | 450 | |
| @@ -2873,20 +2873,27 @@ static void nested_get_vmcs12_pages(struct kvm_vcpu *vcpu) · 2872 unmodified lines | ||
| 2873 | 2873 | /* |
| 2874 | 2874 | * If translation failed, VM entry will fail because |
| 2875 | 2875 | * prepare_vmcs02 set VIRTUAL_APIC_PAGE_ADDR to -1ull. |
| 2876 | − * Failing the vm entry is _not_ what the processor | |
| 2877 | − * does but it's basically the only possibility we | |
| 2878 | − * have. We could still enter the guest if CR8 load | |
| 2879 | − * exits are enabled, CR8 store exits are enabled, and | |
| 2880 | − * virtualize APIC access is disabled; in this case | |
| 2881 | − * the processor would never use the TPR shadow and we | |
| 2882 | − * could simply clear the bit from the execution | |
| 2883 | − * control. But such a configuration is useless, so | |
| 2884 | − * let's keep the code simple. | |
| 2885 | 2876 | */ |
| 2886 | 2877 | if (!is_error_page(page)) { |
| 2887 | 2878 | vmx->nested.virtual_apic_page = page; |
| 2888 | 2879 | hpa = page_to_phys(vmx->nested.virtual_apic_page); |
| 2889 | 2880 | vmcs_write64(VIRTUAL_APIC_PAGE_ADDR, hpa); |
| 2881 | + } else if (nested_cpu_has(vmcs12, CPU_BASED_CR8_LOAD_EXITING) && | |
| 2882 | + nested_cpu_has(vmcs12, CPU_BASED_CR8_STORE_EXITING) && | |
| 2883 | + !nested_cpu_has2(vmcs12, SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES)) { | |
| 2884 | + /* | |
| 2885 | + * The processor will never use the TPR shadow, simply | |
| 2886 | + * clear the bit from the execution control. Such a | |
| 2887 | + * configuration is useless, but it happens in tests. | |
| 2888 | + * For any other configuration, failing the vm entry is | |
| 2889 | + * _not_ what the processor does but it's basically the | |
| 2890 | + * only possibility we have. | |
| 2891 | + */ | |
| 2892 | + vmcs_clear_bits(CPU_BASED_VM_EXEC_CONTROL, | |
| 2893 | + CPU_BASED_TPR_SHADOW); | |
| 2894 | + } else { | |
| 2895 | + printk("bad virtual-APIC page address\n"); | |
| 2896 | + dump_vmcs(); | |
| 2890 | 2897 | } |
| 2891 | 2898 | } |
| 2892 | 2899 | |
| @@ -3789,8 +3796,18 @@ static void nested_vmx_restore_host_state(struct kvm_vcpu *vcpu) · 896 unmodified lines | ||
| 3789 | 3796 | vmx_set_cr4(vcpu, vmcs_readl(CR4_READ_SHADOW)); |
| 3790 | 3797 | |
| 3791 | 3798 | nested_ept_uninit_mmu_context(vcpu); |
| 3792 | − vcpu->arch.cr3 = vmcs_readl(GUEST_CR3); | |
| 3793 | − __set_bit(VCPU_EXREG_CR3, (ulong *)&vcpu->arch.regs_avail); | |
| 3799 | + | |
| 3800 | + /* | |
| 3801 | + * This is only valid if EPT is in use, otherwise the vmcs01 GUEST_CR3 | |
| 3802 | + * points to shadow pages! Fortunately we only get here after a WARN_ON | |
| 3803 | + * if EPT is disabled, so a VMabort is perfectly fine. | |
| 3804 | + */ | |
| 3805 | + if (enable_ept) { | |
| 3806 | + vcpu->arch.cr3 = vmcs_readl(GUEST_CR3); | |
| 3807 | + __set_bit(VCPU_EXREG_CR3, (ulong *)&vcpu->arch.regs_avail); | |
| 3808 | + } else { | |
| 3809 | + nested_vmx_abort(vcpu, VMX_ABORT_VMCS_CORRUPTED); | |
| 3810 | + } | |
| 3794 | 3811 | |
| 3795 | 3812 | /* |
| 3796 | 3813 | * Use ept_save_pdptrs(vcpu) to load the MMU's cached PDPTRs |
| @@ -5738,6 +5755,14 @@ __init int nested_vmx_hardware_setup(int (*exit_handlers[])(struct kvm_vcpu *)) · 1941 unmodified lines | ||
| 5738 | 5755 | { |
| 5739 | 5756 | int i; |
| 5740 | 5757 | |
| 5758 | + /* | |
| 5759 | + * Without EPT it is not possible to restore L1's CR3 and PDPTR on | |
| 5760 | + * VMfail, because they are not available in vmcs01. Just always | |
| 5761 | + * use hardware checks. | |
| 5762 | + */ | |
| 5763 | + if (!enable_ept) | |
| 5764 | + nested_early_check = 1; | |
| 5765 | + | |
| 5741 | 5766 | if (!cpu_has_vmx_shadow_vmcs()) |
| 5742 | 5767 | enable_shadow_vmcs = 0; |
| 5743 | 5768 | if (enable_shadow_vmcs) { |
| @@ -5603,7 +5603,7 @@ static void vmx_dump_dtsel(char *name, uint32_t limit) · 5602 unmodified lines | ||
| 5603 | 5603 | vmcs_readl(limit + GUEST_GDTR_BASE - GUEST_GDTR_LIMIT)); |
| 5604 | 5604 | } |
| 5605 | 5605 | |
| 5606 | −static void dump_vmcs(void) | |
| 5606 | +void dump_vmcs(void) | |
| 5607 | 5607 | { |
| 5608 | 5608 | u32 vmentry_ctl = vmcs_read32(VM_ENTRY_CONTROLS); |
| 5609 | 5609 | u32 vmexit_ctl = vmcs_read32(VM_EXIT_CONTROLS); |
| @@ -6410,6 +6410,8 @@ static void vmx_vcpu_run(struct kvm_vcpu *vcpu) · 800 unmodified lines | ||
| 6410 | 6410 | if (vcpu->guest_debug & KVM_GUESTDBG_SINGLESTEP) |
| 6411 | 6411 | vmx_set_interrupt_shadow(vcpu, 0); |
| 6412 | 6412 | |
| 6413 | + kvm_load_guest_xcr0(vcpu); | |
| 6414 | + | |
| 6413 | 6415 | if (static_cpu_has(X86_FEATURE_PKU) && |
| 6414 | 6416 | kvm_read_cr4_bits(vcpu, X86_CR4_PKE) && |
| 6415 | 6417 | vcpu->arch.pkru != vmx->host_pkru) |
| @@ -6506,6 +6508,8 @@ static void vmx_vcpu_run(struct kvm_vcpu *vcpu) · 90 unmodified lines | ||
| 6506 | 6508 | __write_pkru(vmx->host_pkru); |
| 6507 | 6509 | } |
| 6508 | 6510 | |
| 6511 | + kvm_put_guest_xcr0(vcpu); | |
| 6512 | + | |
| 6509 | 6513 | vmx->nested.nested_run_pending = 0; |
| 6510 | 6514 | vmx->idt_vectoring_info = 0; |
| 6511 | 6515 | |
| @@ -6852,6 +6856,30 @@ static void nested_vmx_entry_exit_ctls_update(struct kvm_vcpu *vcpu) · 340 unmodified lines | ||
| 6852 | 6856 | } |
| 6853 | 6857 | } |
| 6854 | 6858 | |
| 6859 | +static bool guest_cpuid_has_pmu(struct kvm_vcpu *vcpu) | |
| 6860 | +{ | |
| 6861 | + struct kvm_cpuid_entry2 *entry; | |
| 6862 | + union cpuid10_eax eax; | |
| 6863 | + | |
| 6864 | + entry = kvm_find_cpuid_entry(vcpu, 0xa, 0); | |
| 6865 | + if (!entry) | |
| 6866 | + return false; | |
| 6867 | + | |
| 6868 | + eax.full = entry->eax; | |
| 6869 | + return (eax.split.version_id > 0); | |
| 6870 | +} | |
| 6871 | + | |
| 6872 | +static void nested_vmx_procbased_ctls_update(struct kvm_vcpu *vcpu) | |
| 6873 | +{ | |
| 6874 | + struct vcpu_vmx *vmx = to_vmx(vcpu); | |
| 6875 | + bool pmu_enabled = guest_cpuid_has_pmu(vcpu); | |
| 6876 | + | |
| 6877 | + if (pmu_enabled) | |
| 6878 | + vmx->nested.msrs.procbased_ctls_high |= CPU_BASED_RDPMC_EXITING; | |
| 6879 | + else | |
| 6880 | + vmx->nested.msrs.procbased_ctls_high &= ~CPU_BASED_RDPMC_EXITING; | |
| 6881 | +} | |
| 6882 | + | |
| 6855 | 6883 | static void update_intel_pt_cfg(struct kvm_vcpu *vcpu) |
| 6856 | 6884 | { |
| 6857 | 6885 | struct vcpu_vmx *vmx = to_vmx(vcpu); |
| @@ -6940,6 +6968,7 @@ static void vmx_cpuid_update(struct kvm_vcpu *vcpu) · 82 unmodified lines | ||
| 6940 | 6968 | if (nested_vmx_allowed(vcpu)) { |
| 6941 | 6969 | nested_vmx_cr_fixed1_bits_update(vcpu); |
| 6942 | 6970 | nested_vmx_entry_exit_ctls_update(vcpu); |
| 6971 | + nested_vmx_procbased_ctls_update(vcpu); | |
| 6943 | 6972 | } |
| 6944 | 6973 | |
| 6945 | 6974 | if (boot_cpu_has(X86_FEATURE_INTEL_PT) && |
| @@ -7369,7 +7398,7 @@ static int vmx_pre_enter_smm(struct kvm_vcpu *vcpu, char *smstate) · 423 unmodified lines | ||
| 7369 | 7398 | return 0; |
| 7370 | 7399 | } |
| 7371 | 7400 | |
| 7372 | −static int vmx_pre_leave_smm(struct kvm_vcpu *vcpu, u64 smbase) | |
| 7401 | +static int vmx_pre_leave_smm(struct kvm_vcpu *vcpu, const char *smstate) | |
| 7373 | 7402 | { |
| 7374 | 7403 | struct vcpu_vmx *vmx = to_vmx(vcpu); |
| 7375 | 7404 | int ret; |
| @@ -7380,9 +7409,7 @@ static int vmx_pre_leave_smm(struct kvm_vcpu *vcpu, u64 smbase) · 4 unmodified lines | ||
| 7380 | 7409 | } |
| 7381 | 7410 | |
| 7382 | 7411 | if (vmx->nested.smm.guest_mode) { |
| 7383 | − vcpu->arch.hflags &= ~HF_SMM_MASK; | |
| 7384 | 7412 | ret = nested_vmx_enter_non_root_mode(vcpu, false); |
| 7385 | − vcpu->arch.hflags |= HF_SMM_MASK; | |
| 7386 | 7413 | if (ret) |
| 7387 | 7414 | return ret; |
| 7388 | 7415 | |
| @@ -517,4 +517,6 @@ static inline void decache_tsc_multiplier(struct vcpu_vmx *vmx) · 516 unmodified lines | ||
| 517 | 517 | vmcs_write64(TSC_MULTIPLIER, vmx->current_tsc_ratio); |
| 518 | 518 | } |
| 519 | 519 | |
| 520 | +void dump_vmcs(void); | |
| 521 | + | |
| 520 | 522 | #endif /* __KVM_X86_VMX_H */ |
| @@ -800,7 +800,7 @@ void kvm_lmsw(struct kvm_vcpu *vcpu, unsigned long msw) · 799 unmodified lines | ||
| 800 | 800 | } |
| 801 | 801 | EXPORT_SYMBOL_GPL(kvm_lmsw); |
| 802 | 802 | |
| 803 | −static void kvm_load_guest_xcr0(struct kvm_vcpu *vcpu) | |
| 803 | +void kvm_load_guest_xcr0(struct kvm_vcpu *vcpu) | |
| 804 | 804 | { |
| 805 | 805 | if (kvm_read_cr4_bits(vcpu, X86_CR4_OSXSAVE) && |
| 806 | 806 | !vcpu->guest_xcr0_loaded) { |
| @@ -810,8 +810,9 @@ static void kvm_load_guest_xcr0(struct kvm_vcpu *vcpu) · 3 unmodified lines | ||
| 810 | 810 | vcpu->guest_xcr0_loaded = 1; |
| 811 | 811 | } |
| 812 | 812 | } |
| 813 | +EXPORT_SYMBOL_GPL(kvm_load_guest_xcr0); | |
| 813 | 814 | |
| 814 | −static void kvm_put_guest_xcr0(struct kvm_vcpu *vcpu) | |
| 815 | +void kvm_put_guest_xcr0(struct kvm_vcpu *vcpu) | |
| 815 | 816 | { |
| 816 | 817 | if (vcpu->guest_xcr0_loaded) { |
| 817 | 818 | if (vcpu->arch.xcr0 != host_xcr0) |
| @@ -819,6 +820,7 @@ static void kvm_put_guest_xcr0(struct kvm_vcpu *vcpu) · 1 unmodified line | ||
| 819 | 820 | vcpu->guest_xcr0_loaded = 0; |
| 820 | 821 | } |
| 821 | 822 | } |
| 823 | +EXPORT_SYMBOL_GPL(kvm_put_guest_xcr0); | |
| 822 | 824 | |
| 823 | 825 | static int __kvm_set_xcr(struct kvm_vcpu *vcpu, u32 index, u64 xcr) |
| 824 | 826 | { |
| @@ -3093,7 +3095,7 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext) · 2268 unmodified lines | ||
| 3093 | 3095 | break; |
| 3094 | 3096 | case KVM_CAP_NESTED_STATE: |
| 3095 | 3097 | r = kvm_x86_ops->get_nested_state ? |
| 3096 | − kvm_x86_ops->get_nested_state(NULL, 0, 0) : 0; | |
| 3098 | + kvm_x86_ops->get_nested_state(NULL, NULL, 0) : 0; | |
| 3097 | 3099 | break; |
| 3098 | 3100 | default: |
| 3099 | 3101 | break; |
| @@ -3528,7 +3530,7 @@ static void kvm_vcpu_ioctl_x86_get_vcpu_events(struct kvm_vcpu *vcpu, · 428 unmodified lines | ||
| 3528 | 3530 | memset(&events->reserved, 0, sizeof(events->reserved)); |
| 3529 | 3531 | } |
| 3530 | 3532 | |
| 3531 | −static void kvm_set_hflags(struct kvm_vcpu *vcpu, unsigned emul_flags); | |
| 3533 | +static void kvm_smm_changed(struct kvm_vcpu *vcpu); | |
| 3532 | 3534 | |
| 3533 | 3535 | static int kvm_vcpu_ioctl_x86_set_vcpu_events(struct kvm_vcpu *vcpu, |
| 3534 | 3536 | struct kvm_vcpu_events *events) |
| @@ -3588,12 +3590,13 @@ static int kvm_vcpu_ioctl_x86_set_vcpu_events(struct kvm_vcpu *vcpu, · 53 unmodified lines | ||
| 3588 | 3590 | vcpu->arch.apic->sipi_vector = events->sipi_vector; |
| 3589 | 3591 | |
| 3590 | 3592 | if (events->flags & KVM_VCPUEVENT_VALID_SMM) { |
| 3591 | − u32 hflags = vcpu->arch.hflags; | |
| 3592 | − if (events->smi.smm) | |
| 3593 | − hflags |= HF_SMM_MASK; | |
| 3594 | − else | |
| 3595 | − hflags &= ~HF_SMM_MASK; | |
| 3596 | − kvm_set_hflags(vcpu, hflags); | |
| 3593 | + if (!!(vcpu->arch.hflags & HF_SMM_MASK) != events->smi.smm) { | |
| 3594 | + if (events->smi.smm) | |
| 3595 | + vcpu->arch.hflags |= HF_SMM_MASK; | |
| 3596 | + else | |
| 3597 | + vcpu->arch.hflags &= ~HF_SMM_MASK; | |
| 3598 | + kvm_smm_changed(vcpu); | |
| 3599 | + } | |
| 3597 | 3600 | |
| 3598 | 3601 | vcpu->arch.smi_pending = events->smi.pending; |
| 3599 | 3602 | |
| @@ -4270,7 +4273,7 @@ static int kvm_vm_ioctl_set_identity_map_addr(struct kvm *kvm, · 670 unmodified lines | ||
| 4270 | 4273 | } |
| 4271 | 4274 | |
| 4272 | 4275 | static int kvm_vm_ioctl_set_nr_mmu_pages(struct kvm *kvm, |
| 4273 | − u32 kvm_nr_mmu_pages) | |
| 4276 | + unsigned long kvm_nr_mmu_pages) | |
| 4274 | 4277 | { |
| 4275 | 4278 | if (kvm_nr_mmu_pages < KVM_MIN_ALLOC_MMU_PAGES) |
| 4276 | 4279 | return -EINVAL; |
| @@ -4284,7 +4287,7 @@ static int kvm_vm_ioctl_set_nr_mmu_pages(struct kvm *kvm, · 7 unmodified lines | ||
| 4284 | 4287 | return 0; |
| 4285 | 4288 | } |
| 4286 | 4289 | |
| 4287 | −static int kvm_vm_ioctl_get_nr_mmu_pages(struct kvm *kvm) | |
| 4290 | +static unsigned long kvm_vm_ioctl_get_nr_mmu_pages(struct kvm *kvm) | |
| 4288 | 4291 | { |
| 4289 | 4292 | return kvm->arch.n_max_mmu_pages; |
| 4290 | 4293 | } |
| @@ -5958,12 +5961,18 @@ static unsigned emulator_get_hflags(struct x86_emulate_ctxt *ctxt) · 1667 unmodified lines | ||
| 5958 | 5961 | |
| 5959 | 5962 | static void emulator_set_hflags(struct x86_emulate_ctxt *ctxt, unsigned emul_flags) |
| 5960 | 5963 | { |
| 5961 | − kvm_set_hflags(emul_to_vcpu(ctxt), emul_flags); | |
| 5964 | + emul_to_vcpu(ctxt)->arch.hflags = emul_flags; | |
| 5965 | +} | |
| 5966 | + | |
| 5967 | +static int emulator_pre_leave_smm(struct x86_emulate_ctxt *ctxt, | |
| 5968 | + const char *smstate) | |
| 5969 | +{ | |
| 5970 | + return kvm_x86_ops->pre_leave_smm(emul_to_vcpu(ctxt), smstate); | |
| 5962 | 5971 | } |
| 5963 | 5972 | |
| 5964 | −static int emulator_pre_leave_smm(struct x86_emulate_ctxt *ctxt, u64 smbase) | |
| 5973 | +static void emulator_post_leave_smm(struct x86_emulate_ctxt *ctxt) | |
| 5965 | 5974 | { |
| 5966 | − return kvm_x86_ops->pre_leave_smm(emul_to_vcpu(ctxt), smbase); | |
| 5975 | + kvm_smm_changed(emul_to_vcpu(ctxt)); | |
| 5967 | 5976 | } |
| 5968 | 5977 | |
| 5969 | 5978 | static const struct x86_emulate_ops emulate_ops = { |
| @@ -6006,6 +6015,7 @@ static const struct x86_emulate_ops emulate_ops = { · 36 unmodified lines | ||
| 6006 | 6015 | .get_hflags = emulator_get_hflags, |
| 6007 | 6016 | .set_hflags = emulator_set_hflags, |
| 6008 | 6017 | .pre_leave_smm = emulator_pre_leave_smm, |
| 6018 | + .post_leave_smm = emulator_post_leave_smm, | |
| 6009 | 6019 | }; |
| 6010 | 6020 | |
| 6011 | 6021 | static void toggle_interruptibility(struct kvm_vcpu *vcpu, u32 mask) |
| @@ -6247,16 +6257,6 @@ static void kvm_smm_changed(struct kvm_vcpu *vcpu) · 235 unmodified lines | ||
| 6247 | 6257 | kvm_mmu_reset_context(vcpu); |
| 6248 | 6258 | } |
| 6249 | 6259 | |
| 6250 | −static void kvm_set_hflags(struct kvm_vcpu *vcpu, unsigned emul_flags) | |
| 6251 | −{ | |
| 6252 | − unsigned changed = vcpu->arch.hflags ^ emul_flags; | |
| 6253 | − | |
| 6254 | − vcpu->arch.hflags = emul_flags; | |
| 6255 | − | |
| 6256 | − if (changed & HF_SMM_MASK) | |
| 6257 | − kvm_smm_changed(vcpu); | |
| 6258 | −} | |
| 6259 | − | |
| 6260 | 6260 | static int kvm_vcpu_check_hw_bp(unsigned long addr, u32 type, u32 dr7, |
| 6261 | 6261 | unsigned long *db) |
| 6262 | 6262 | { |
| @@ -7441,9 +7441,9 @@ static void enter_smm_save_state_32(struct kvm_vcpu *vcpu, char *buf) · 1178 unmodified lines | ||
| 7441 | 7441 | put_smstate(u32, buf, 0x7ef8, vcpu->arch.smbase); |
| 7442 | 7442 | } |
| 7443 | 7443 | |
| 7444 | +#ifdef CONFIG_X86_64 | |
| 7444 | 7445 | static void enter_smm_save_state_64(struct kvm_vcpu *vcpu, char *buf) |
| 7445 | 7446 | { |
| 7446 | −#ifdef CONFIG_X86_64 | |
| 7447 | 7447 | struct desc_ptr dt; |
| 7448 | 7448 | struct kvm_segment seg; |
| 7449 | 7449 | unsigned long val; |
| @@ -7493,10 +7493,8 @@ static void enter_smm_save_state_64(struct kvm_vcpu *vcpu, char *buf) · 43 unmodified lines | ||
| 7493 | 7493 | |
| 7494 | 7494 | for (i = 0; i < 6; i++) |
| 7495 | 7495 | enter_smm_save_seg_64(vcpu, buf, i); |
| 7496 | −#else | |
| 7497 | − WARN_ON_ONCE(1); | |
| 7498 | −#endif | |
| 7499 | 7496 | } |
| 7497 | +#endif | |
| 7500 | 7498 | |
| 7501 | 7499 | static void enter_smm(struct kvm_vcpu *vcpu) |
| 7502 | 7500 | { |
| @@ -7507,9 +7505,11 @@ static void enter_smm(struct kvm_vcpu *vcpu) · 4 unmodified lines | ||
| 7507 | 7505 | |
| 7508 | 7506 | trace_kvm_enter_smm(vcpu->vcpu_id, vcpu->arch.smbase, true); |
| 7509 | 7507 | memset(buf, 0, 512); |
| 7508 | +#ifdef CONFIG_X86_64 | |
| 7510 | 7509 | if (guest_cpuid_has(vcpu, X86_FEATURE_LM)) |
| 7511 | 7510 | enter_smm_save_state_64(vcpu, buf); |
| 7512 | 7511 | else |
| 7512 | +#endif | |
| 7513 | 7513 | enter_smm_save_state_32(vcpu, buf); |
| 7514 | 7514 | |
| 7515 | 7515 | /* |
| @@ -7567,8 +7567,10 @@ static void enter_smm(struct kvm_vcpu *vcpu) · 51 unmodified lines | ||
| 7567 | 7567 | kvm_set_segment(vcpu, &ds, VCPU_SREG_GS); |
| 7568 | 7568 | kvm_set_segment(vcpu, &ds, VCPU_SREG_SS); |
| 7569 | 7569 | |
| 7570 | +#ifdef CONFIG_X86_64 | |
| 7570 | 7571 | if (guest_cpuid_has(vcpu, X86_FEATURE_LM)) |
| 7571 | 7572 | kvm_x86_ops->set_efer(vcpu, 0); |
| 7573 | +#endif | |
| 7572 | 7574 | |
| 7573 | 7575 | kvm_update_cpuid(vcpu); |
| 7574 | 7576 | kvm_mmu_reset_context(vcpu); |
| @@ -7865,8 +7867,6 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu) · 290 unmodified lines | ||
| 7865 | 7867 | goto cancel_injection; |
| 7866 | 7868 | } |
| 7867 | 7869 | |
| 7868 | − kvm_load_guest_xcr0(vcpu); | |
| 7869 | − | |
| 7870 | 7870 | if (req_immediate_exit) { |
| 7871 | 7871 | kvm_make_request(KVM_REQ_EVENT, vcpu); |
| 7872 | 7872 | kvm_x86_ops->request_immediate_exit(vcpu); |
| @@ -7919,8 +7919,6 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu) · 46 unmodified lines | ||
| 7919 | 7919 | vcpu->mode = OUTSIDE_GUEST_MODE; |
| 7920 | 7920 | smp_wmb(); |
| 7921 | 7921 | |
| 7922 | − kvm_put_guest_xcr0(vcpu); | |
| 7923 | − | |
| 7924 | 7922 | kvm_before_interrupt(vcpu); |
| 7925 | 7923 | kvm_x86_ops->handle_external_intr(vcpu); |
| 7926 | 7924 | kvm_after_interrupt(vcpu); |
| @@ -347,4 +347,6 @@ static inline void kvm_after_interrupt(struct kvm_vcpu *vcpu) · 346 unmodified lines | ||
| 347 | 347 | __this_cpu_write(current_vcpu, NULL); |
| 348 | 348 | } |
| 349 | 349 | |
| 350 | +void kvm_load_guest_xcr0(struct kvm_vcpu *vcpu); | |
| 351 | +void kvm_put_guest_xcr0(struct kvm_vcpu *vcpu); | |
| 350 | 352 | #endif |
| @@ -2822,7 +2822,7 @@ static void bfq_dispatch_remove(struct request_queue *q, struct request *rq) · 2821 unmodified lines | ||
| 2822 | 2822 | bfq_remove_request(q, rq); |
| 2823 | 2823 | } |
| 2824 | 2824 | |
| 2825 | −static void __bfq_bfqq_expire(struct bfq_data *bfqd, struct bfq_queue *bfqq) | |
| 2825 | +static bool __bfq_bfqq_expire(struct bfq_data *bfqd, struct bfq_queue *bfqq) | |
| 2826 | 2826 | { |
| 2827 | 2827 | /* |
| 2828 | 2828 | * If this bfqq is shared between multiple processes, check |
| @@ -2855,9 +2855,11 @@ static void __bfq_bfqq_expire(struct bfq_data *bfqd, struct bfq_queue *bfqq) · 26 unmodified lines | ||
| 2855 | 2855 | /* |
| 2856 | 2856 | * All in-service entities must have been properly deactivated |
| 2857 | 2857 | * or requeued before executing the next function, which |
| 2858 | − * resets all in-service entites as no more in service. | |
| 2858 | + * resets all in-service entities as no more in service. This | |
| 2859 | + * may cause bfqq to be freed. If this happens, the next | |
| 2860 | + * function returns true. | |
| 2859 | 2861 | */ |
| 2860 | − __bfq_bfqd_reset_in_service(bfqd); | |
| 2862 | + return __bfq_bfqd_reset_in_service(bfqd); | |
| 2861 | 2863 | } |
| 2862 | 2864 | |
| 2863 | 2865 | /** |
| @@ -3262,7 +3264,6 @@ void bfq_bfqq_expire(struct bfq_data *bfqd, · 398 unmodified lines | ||
| 3262 | 3264 | bool slow; |
| 3263 | 3265 | unsigned long delta = 0; |
| 3264 | 3266 | struct bfq_entity *entity = &bfqq->entity; |
| 3265 | − int ref; | |
| 3266 | 3267 | |
| 3267 | 3268 | /* |
| 3268 | 3269 | * Check whether the process is slow (see bfq_bfqq_is_slow). |
| @@ -3347,10 +3348,8 @@ void bfq_bfqq_expire(struct bfq_data *bfqd, · 78 unmodified lines | ||
| 3347 | 3348 | * reason. |
| 3348 | 3349 | */ |
| 3349 | 3350 | __bfq_bfqq_recalc_budget(bfqd, bfqq, reason); |
| 3350 | − ref = bfqq->ref; | |
| 3351 | − __bfq_bfqq_expire(bfqd, bfqq); | |
| 3352 | − | |
| 3353 | − if (ref == 1) /* bfqq is gone, no more actions on it */ | |
| 3351 | + if (__bfq_bfqq_expire(bfqd, bfqq)) | |
| 3352 | + /* bfqq is gone, no more actions on it */ | |
| 3354 | 3353 | return; |
| 3355 | 3354 | |
| 3356 | 3355 | bfqq->injected_service = 0; |
| @@ -995,7 +995,7 @@ bool __bfq_deactivate_entity(struct bfq_entity *entity, · 994 unmodified lines | ||
| 995 | 995 | bool ins_into_idle_tree); |
| 996 | 996 | bool next_queue_may_preempt(struct bfq_data *bfqd); |
| 997 | 997 | struct bfq_queue *bfq_get_next_queue(struct bfq_data *bfqd); |
| 998 | −void __bfq_bfqd_reset_in_service(struct bfq_data *bfqd); | |
| 998 | +bool __bfq_bfqd_reset_in_service(struct bfq_data *bfqd); | |
| 999 | 999 | void bfq_deactivate_bfqq(struct bfq_data *bfqd, struct bfq_queue *bfqq, |
| 1000 | 1000 | bool ins_into_idle_tree, bool expiration); |
| 1001 | 1001 | void bfq_activate_bfqq(struct bfq_data *bfqd, struct bfq_queue *bfqq); |
| @@ -1605,7 +1605,8 @@ struct bfq_queue *bfq_get_next_queue(struct bfq_data *bfqd) · 1604 unmodified lines | ||
| 1605 | 1605 | return bfqq; |
| 1606 | 1606 | } |
| 1607 | 1607 | |
| 1608 | −void __bfq_bfqd_reset_in_service(struct bfq_data *bfqd) | |
| 1608 | +/* returns true if the in-service queue gets freed */ | |
| 1609 | +bool __bfq_bfqd_reset_in_service(struct bfq_data *bfqd) | |
| 1609 | 1610 | { |
| 1610 | 1611 | struct bfq_queue *in_serv_bfqq = bfqd->in_service_queue; |
| 1611 | 1612 | struct bfq_entity *in_serv_entity = &in_serv_bfqq->entity; |
| @@ -1629,8 +1630,20 @@ void __bfq_bfqd_reset_in_service(struct bfq_data *bfqd) · 17 unmodified lines | ||
| 1629 | 1630 | * service tree either, then release the service reference to |
| 1630 | 1631 | * the queue it represents (taken with bfq_get_entity). |
| 1631 | 1632 | */ |
| 1632 | − if (!in_serv_entity->on_st) | |
| 1633 | + if (!in_serv_entity->on_st) { | |
| 1634 | + /* | |
| 1635 | + * If no process is referencing in_serv_bfqq any | |
| 1636 | + * longer, then the service reference may be the only | |
| 1637 | + * reference to the queue. If this is the case, then | |
| 1638 | + * bfqq gets freed here. | |
| 1639 | + */ | |
| 1640 | + int ref = in_serv_bfqq->ref; | |
| 1633 | 1641 | bfq_put_queue(in_serv_bfqq); |
| 1642 | + if (ref == 1) | |
| 1643 | + return true; | |
| 1644 | + } | |
| 1645 | + | |
| 1646 | + return false; | |
| 1634 | 1647 | } |
| 1635 | 1648 | |
| 1636 | 1649 | void bfq_deactivate_bfqq(struct bfq_data *bfqd, struct bfq_queue *bfqq, |
| @@ -1298,8 +1298,11 @@ struct bio *bio_copy_user_iov(struct request_queue *q, · 1297 unmodified lines | ||
| 1298 | 1298 | } |
| 1299 | 1299 | } |
| 1300 | 1300 | |
| 1301 | − if (bio_add_pc_page(q, bio, page, bytes, offset) < bytes) | |
| 1301 | + if (bio_add_pc_page(q, bio, page, bytes, offset) < bytes) { | |
| 1302 | + if (!map_data) | |
| 1303 | + __free_page(page); | |
| 1302 | 1304 | break; |
| 1305 | + } | |
| 1303 | 1306 | |
| 1304 | 1307 | len -= bytes; |
| 1305 | 1308 | offset = 0; |
| @@ -654,6 +654,13 @@ bool blk_mq_complete_request(struct request *rq) · 653 unmodified lines | ||
| 654 | 654 | } |
| 655 | 655 | EXPORT_SYMBOL(blk_mq_complete_request); |
| 656 | 656 | |
| 657 | +void blk_mq_complete_request_sync(struct request *rq) | |
| 658 | +{ | |
| 659 | + WRITE_ONCE(rq->state, MQ_RQ_COMPLETE); | |
| 660 | + rq->q->mq_ops->complete(rq); | |
| 661 | +} | |
| 662 | +EXPORT_SYMBOL_GPL(blk_mq_complete_request_sync); | |
| 663 | + | |
| 657 | 664 | int blk_mq_request_started(struct request *rq) |
| 658 | 665 | { |
| 659 | 666 | return blk_mq_rq_state(rq) != MQ_RQ_IDLE; |
| @@ -186,6 +186,10 @@ void acpi_ns_detach_object(struct acpi_namespace_node *node) · 185 unmodified lines | ||
| 186 | 186 | } |
| 187 | 187 | } |
| 188 | 188 | |
| 189 | + if (obj_desc->common.type == ACPI_TYPE_REGION) { | |
| 190 | + acpi_ut_remove_address_range(obj_desc->region.space_id, node); | |
| 191 | + } | |
| 192 | + | |
| 189 | 193 | /* Clear the Node entry in all cases */ |
| 190 | 194 | |
| 191 | 195 | node->object = NULL; |
| @@ -567,6 +567,12 @@ int acpi_nfit_ctl(struct nvdimm_bus_descriptor *nd_desc, struct nvdimm *nvdimm, · 566 unmodified lines | ||
| 567 | 567 | goto out; |
| 568 | 568 | } |
| 569 | 569 | |
| 570 | + dev_dbg(dev, "%s cmd: %s output length: %d\n", dimm_name, | |
| 571 | + cmd_name, out_obj->buffer.length); | |
| 572 | + print_hex_dump_debug(cmd_name, DUMP_PREFIX_OFFSET, 4, 4, | |
| 573 | + out_obj->buffer.pointer, | |
| 574 | + min_t(u32, 128, out_obj->buffer.length), true); | |
| 575 | + | |
| 570 | 576 | if (call_pkg) { |
| 571 | 577 | call_pkg->nd_fw_size = out_obj->buffer.length; |
| 572 | 578 | memcpy(call_pkg->nd_payload + call_pkg->nd_size_in, |
| @@ -585,12 +591,6 @@ int acpi_nfit_ctl(struct nvdimm_bus_descriptor *nd_desc, struct nvdimm *nvdimm, · 12 unmodified lines | ||
| 585 | 591 | return 0; |
| 586 | 592 | } |
| 587 | 593 | |
| 588 | − dev_dbg(dev, "%s cmd: %s output length: %d\n", dimm_name, | |
| 589 | − cmd_name, out_obj->buffer.length); | |
| 590 | − print_hex_dump_debug(cmd_name, DUMP_PREFIX_OFFSET, 4, 4, | |
| 591 | − out_obj->buffer.pointer, | |
| 592 | − min_t(u32, 128, out_obj->buffer.length), true); | |
| 593 | − | |
| 594 | 594 | for (i = 0, offset = 0; i < desc->out_num; i++) { |
| 595 | 595 | u32 out_size = nd_cmd_out_size(nvdimm, cmd, desc, i, buf, |
| 596 | 596 | (u32 *) out_obj->buffer.pointer, |
| @@ -122,9 +122,8 @@ static int intel_security_change_key(struct nvdimm *nvdimm, · 121 unmodified lines | ||
| 122 | 122 | if (!test_bit(cmd, &nfit_mem->dsm_mask)) |
| 123 | 123 | return -ENOTTY; |
| 124 | 124 | |
| 125 | − if (old_data) | |
| 126 | − memcpy(nd_cmd.cmd.old_pass, old_data->data, | |
| 127 | − sizeof(nd_cmd.cmd.old_pass)); | |
| 125 | + memcpy(nd_cmd.cmd.old_pass, old_data->data, | |
| 126 | + sizeof(nd_cmd.cmd.old_pass)); | |
| 128 | 127 | memcpy(nd_cmd.cmd.new_pass, new_data->data, |
| 129 | 128 | sizeof(nd_cmd.cmd.new_pass)); |
| 130 | 129 | rc = nvdimm_ctl(nvdimm, ND_CMD_CALL, &nd_cmd, sizeof(nd_cmd), NULL); |
| @@ -336,9 +335,8 @@ static int __maybe_unused intel_security_overwrite(struct nvdimm *nvdimm, · 205 unmodified lines | ||
| 336 | 335 | |
| 337 | 336 | /* flush all cache before we erase DIMM */ |
| 338 | 337 | nvdimm_invalidate_cache(); |
| 339 | − if (nkey) | |
| 340 | − memcpy(nd_cmd.cmd.passphrase, nkey->data, | |
| 341 | − sizeof(nd_cmd.cmd.passphrase)); | |
| 338 | + memcpy(nd_cmd.cmd.passphrase, nkey->data, | |
| 339 | + sizeof(nd_cmd.cmd.passphrase)); | |
| 342 | 340 | rc = nvdimm_ctl(nvdimm, ND_CMD_CALL, &nd_cmd, sizeof(nd_cmd), NULL); |
| 343 | 341 | if (rc < 0) |
| 344 | 342 | return rc; |
| @@ -513,6 +513,8 @@ static int init_vq(struct virtio_blk *vblk) · 512 unmodified lines | ||
| 513 | 513 | if (err) |
| 514 | 514 | num_vqs = 1; |
| 515 | 515 | |
| 516 | + num_vqs = min_t(unsigned int, nr_cpu_ids, num_vqs); | |
| 517 | + | |
| 516 | 518 | vblk->vqs = kmalloc_array(num_vqs, sizeof(*vblk->vqs), GFP_KERNEL); |
| 517 | 519 | if (!vblk->vqs) |
| 518 | 520 | return -ENOMEM; |
| @@ -2942,6 +2942,7 @@ static int btusb_config_oob_wake(struct hci_dev *hdev) · 2941 unmodified lines | ||
| 2942 | 2942 | return 0; |
| 2943 | 2943 | } |
| 2944 | 2944 | |
| 2945 | + irq_set_status_flags(irq, IRQ_NOAUTOEN); | |
| 2945 | 2946 | ret = devm_request_irq(&hdev->dev, irq, btusb_oob_wake_handler, |
| 2946 | 2947 | 0, "OOB Wake-on-BT", data); |
| 2947 | 2948 | if (ret) { |
| @@ -2956,7 +2957,6 @@ static int btusb_config_oob_wake(struct hci_dev *hdev) · 8 unmodified lines | ||
| 2956 | 2957 | } |
| 2957 | 2958 | |
| 2958 | 2959 | data->oob_wake_irq = irq; |
| 2959 | − disable_irq(irq); | |
| 2960 | 2960 | bt_dev_info(hdev, "OOB Wake-on-BT configured at IRQ %u", irq); |
| 2961 | 2961 | return 0; |
| 2962 | 2962 | } |
| @@ -66,7 +66,6 @@ static void __init dmi_add_platform_ipmi(unsigned long base_addr, · 65 unmodified lines | ||
| 66 | 66 | return; |
| 67 | 67 | } |
| 68 | 68 | |
| 69 | − memset(&p, 0, sizeof(p)); | |
| 70 | 69 | p.addr = base_addr; |
| 71 | 70 | p.space = space; |
| 72 | 71 | p.regspacing = offset; |
| @@ -214,6 +214,9 @@ struct ipmi_user { · 213 unmodified lines | ||
| 214 | 214 | |
| 215 | 215 | /* Does this interface receive IPMI events? */ |
| 216 | 216 | bool gets_events; |
| 217 | + | |
| 218 | + /* Free must run in process context for RCU cleanup. */ | |
| 219 | + struct work_struct remove_work; | |
| 217 | 220 | }; |
| 218 | 221 | |
| 219 | 222 | static struct ipmi_user *acquire_ipmi_user(struct ipmi_user *user, int *index) |
| @@ -1157,6 +1160,15 @@ static int intf_err_seq(struct ipmi_smi *intf, · 937 unmodified lines | ||
| 1157 | 1160 | return rv; |
| 1158 | 1161 | } |
| 1159 | 1162 | |
| 1163 | +static void free_user_work(struct work_struct *work) | |
| 1164 | +{ | |
| 1165 | + struct ipmi_user *user = container_of(work, struct ipmi_user, | |
| 1166 | + remove_work); | |
| 1167 | + | |
| 1168 | + cleanup_srcu_struct(&user->release_barrier); | |
| 1169 | + kfree(user); | |
| 1170 | +} | |
| 1171 | + | |
| 1160 | 1172 | int ipmi_create_user(unsigned int if_num, |
| 1161 | 1173 | const struct ipmi_user_hndl *handler, |
| 1162 | 1174 | void *handler_data, |
| @@ -1200,6 +1212,8 @@ int ipmi_create_user(unsigned int if_num, · 37 unmodified lines | ||
| 1200 | 1212 | goto out_kfree; |
| 1201 | 1213 | |
| 1202 | 1214 | found: |
| 1215 | + INIT_WORK(&new_user->remove_work, free_user_work); | |
| 1216 | + | |
| 1203 | 1217 | rv = init_srcu_struct(&new_user->release_barrier); |
| 1204 | 1218 | if (rv) |
| 1205 | 1219 | goto out_kfree; |
| @@ -1260,8 +1274,9 @@ EXPORT_SYMBOL(ipmi_get_smi_info); · 54 unmodified lines | ||
| 1260 | 1274 | static void free_user(struct kref *ref) |
| 1261 | 1275 | { |
| 1262 | 1276 | struct ipmi_user *user = container_of(ref, struct ipmi_user, refcount); |
| 1263 | − cleanup_srcu_struct(&user->release_barrier); | |
| 1264 | − kfree(user); | |
| 1277 | + | |
| 1278 | + /* SRCU cleanup must happen in task context. */ | |
| 1279 | + schedule_work(&user->remove_work); | |
| 1265 | 1280 | } |
| 1266 | 1281 | |
| 1267 | 1282 | static void _ipmi_destroy_user(struct ipmi_user *user) |
| @@ -118,6 +118,8 @@ void __init ipmi_hardcode_init(void) · 117 unmodified lines | ||
| 118 | 118 | char *str; |
| 119 | 119 | char *si_type[SI_MAX_PARMS]; |
| 120 | 120 | |
| 121 | + memset(si_type, 0, sizeof(si_type)); | |
| 122 | + | |
| 121 | 123 | /* Parse out the si_type string into its components. */ |
| 122 | 124 | str = si_type_str; |
| 123 | 125 | if (*str != '\0') { |
| @@ -20,8 +20,7 @@ · 19 unmodified lines | ||
| 20 | 20 | #define PROG_ID_MAX 7 |
| 21 | 21 | |
| 22 | 22 | #define PROG_STATUS_MASK(id) (1 << ((id) + 8)) |
| 23 | −#define PROG_PRES_MASK 0x7 | |
| 24 | −#define PROG_PRES(layout, pckr) ((pckr >> layout->pres_shift) & PROG_PRES_MASK) | |
| 23 | +#define PROG_PRES(layout, pckr) ((pckr >> layout->pres_shift) & layout->pres_mask) | |
| 25 | 24 | #define PROG_MAX_RM9200_CSS 3 |
| 26 | 25 | |
| 27 | 26 | struct clk_programmable { |
| @@ -37,20 +36,29 @@ static unsigned long clk_programmable_recalc_rate(struct clk_hw *hw, · 9 unmodified lines | ||
| 37 | 36 | unsigned long parent_rate) |
| 38 | 37 | { |
| 39 | 38 | struct clk_programmable *prog = to_clk_programmable(hw); |
| 39 | + const struct clk_programmable_layout *layout = prog->layout; | |
| 40 | 40 | unsigned int pckr; |
| 41 | + unsigned long rate; | |
| 41 | 42 | |
| 42 | 43 | regmap_read(prog->regmap, AT91_PMC_PCKR(prog->id), &pckr); |
| 43 | 44 | |
| 44 | − return parent_rate >> PROG_PRES(prog->layout, pckr); | |
| 45 | + if (layout->is_pres_direct) | |
| 46 | + rate = parent_rate / (PROG_PRES(layout, pckr) + 1); | |
| 47 | + else | |
| 48 | + rate = parent_rate >> PROG_PRES(layout, pckr); | |
| 49 | + | |
| 50 | + return rate; | |
| 45 | 51 | } |
| 46 | 52 | |
| 47 | 53 | static int clk_programmable_determine_rate(struct clk_hw *hw, |
| 48 | 54 | struct clk_rate_request *req) |
| 49 | 55 | { |
| 56 | + struct clk_programmable *prog = to_clk_programmable(hw); | |
| 57 | + const struct clk_programmable_layout *layout = prog->layout; | |
| 50 | 58 | struct clk_hw *parent; |
| 51 | 59 | long best_rate = -EINVAL; |
| 52 | 60 | unsigned long parent_rate; |
| 53 | − unsigned long tmp_rate; | |
| 61 | + unsigned long tmp_rate = 0; | |
| 54 | 62 | int shift; |
| 55 | 63 | int i; |
| 56 | 64 | |
| @@ -60,10 +68,18 @@ static int clk_programmable_determine_rate(struct clk_hw *hw, · 3 unmodified lines | ||
| 60 | 68 | continue; |
| 61 | 69 | |
| 62 | 70 | parent_rate = clk_hw_get_rate(parent); |
| 63 | − for (shift = 0; shift < PROG_PRES_MASK; shift++) { | |
| 64 | − tmp_rate = parent_rate >> shift; | |
| 65 | − if (tmp_rate <= req->rate) | |
| 66 | − break; | |
| 71 | + if (layout->is_pres_direct) { | |
| 72 | + for (shift = 0; shift <= layout->pres_mask; shift++) { | |
| 73 | + tmp_rate = parent_rate / (shift + 1); | |
| 74 | + if (tmp_rate <= req->rate) | |
| 75 | + break; | |
| 76 | + } | |
| 77 | + } else { | |
| 78 | + for (shift = 0; shift < layout->pres_mask; shift++) { | |
| 79 | + tmp_rate = parent_rate >> shift; | |
| 80 | + if (tmp_rate <= req->rate) | |
| 81 | + break; | |
| 82 | + } | |
| 67 | 83 | } |
| 68 | 84 | |
| 69 | 85 | if (tmp_rate > req->rate) |
| @@ -137,16 +153,23 @@ static int clk_programmable_set_rate(struct clk_hw *hw, unsigned long rate, · 67 unmodified lines | ||
| 137 | 153 | if (!div) |
| 138 | 154 | return -EINVAL; |
| 139 | 155 | |
| 140 | − shift = fls(div) - 1; | |
| 156 | + if (layout->is_pres_direct) { | |
| 157 | + shift = div - 1; | |
| 141 | 158 | |
| 142 | − if (div != (1 << shift)) | |
| 143 | − return -EINVAL; | |
| 159 | + if (shift > layout->pres_mask) | |
| 160 | + return -EINVAL; | |
| 161 | + } else { | |
| 162 | + shift = fls(div) - 1; | |
| 144 | 163 | |
| 145 | − if (shift >= PROG_PRES_MASK) | |
| 146 | − return -EINVAL; | |
| 164 | + if (div != (1 << shift)) | |
| 165 | + return -EINVAL; | |
| 166 | + | |
| 167 | + if (shift >= layout->pres_mask) | |
| 168 | + return -EINVAL; | |
| 169 | + } | |
| 147 | 170 | |
| 148 | 171 | regmap_update_bits(prog->regmap, AT91_PMC_PCKR(prog->id), |
| 149 | − PROG_PRES_MASK << layout->pres_shift, | |
| 172 | + layout->pres_mask << layout->pres_shift, | |
| 150 | 173 | shift << layout->pres_shift); |
| 151 | 174 | |
| 152 | 175 | return 0; |
| @@ -202,19 +225,25 @@ at91_clk_register_programmable(struct regmap *regmap, · 49 unmodified lines | ||
| 202 | 225 | } |
| 203 | 226 | |
| 204 | 227 | const struct clk_programmable_layout at91rm9200_programmable_layout = { |
| 228 | + .pres_mask = 0x7, | |
| 205 | 229 | .pres_shift = 2, |
| 206 | 230 | .css_mask = 0x3, |
| 207 | 231 | .have_slck_mck = 0, |
| 232 | + .is_pres_direct = 0, | |
| 208 | 233 | }; |
| 209 | 234 | |
| 210 | 235 | const struct clk_programmable_layout at91sam9g45_programmable_layout = { |
| 236 | + .pres_mask = 0x7, | |
| 211 | 237 | .pres_shift = 2, |
| 212 | 238 | .css_mask = 0x3, |
| 213 | 239 | .have_slck_mck = 1, |
| 240 | + .is_pres_direct = 0, | |
| 214 | 241 | }; |
| 215 | 242 | |
| 216 | 243 | const struct clk_programmable_layout at91sam9x5_programmable_layout = { |
| 244 | + .pres_mask = 0x7, | |
| 217 | 245 | .pres_shift = 4, |
| 218 | 246 | .css_mask = 0x7, |
| 219 | 247 | .have_slck_mck = 0, |
| 248 | + .is_pres_direct = 0, | |
| 220 | 249 | }; |
| @@ -71,9 +71,11 @@ struct clk_pll_characteristics { · 70 unmodified lines | ||
| 71 | 71 | }; |
| 72 | 72 | |
| 73 | 73 | struct clk_programmable_layout { |
| 74 | + u8 pres_mask; | |
| 74 | 75 | u8 pres_shift; |
| 75 | 76 | u8 css_mask; |
| 76 | 77 | u8 have_slck_mck; |
| 78 | + u8 is_pres_direct; | |
| 77 | 79 | }; |
| 78 | 80 | |
| 79 | 81 | extern const struct clk_programmable_layout at91rm9200_programmable_layout; |
| @@ -125,6 +125,14 @@ static const struct { · 124 unmodified lines | ||
| 125 | 125 | .pll = true }, |
| 126 | 126 | }; |
| 127 | 127 | |
| 128 | +static const struct clk_programmable_layout sama5d2_programmable_layout = { | |
| 129 | + .pres_mask = 0xff, | |
| 130 | + .pres_shift = 4, | |
| 131 | + .css_mask = 0x7, | |
| 132 | + .have_slck_mck = 0, | |
| 133 | + .is_pres_direct = 1, | |
| 134 | +}; | |
| 135 | + | |
| 128 | 136 | static void __init sama5d2_pmc_setup(struct device_node *np) |
| 129 | 137 | { |
| 130 | 138 | struct clk_range range = CLK_RANGE(0, 0); |
| @@ -249,7 +257,7 @@ static void __init sama5d2_pmc_setup(struct device_node *np) · 118 unmodified lines | ||
| 249 | 257 | |
| 250 | 258 | hw = at91_clk_register_programmable(regmap, name, |
| 251 | 259 | parent_names, 6, i, |
| 252 | − &at91sam9x5_programmable_layout); | |
| 260 | + &sama5d2_programmable_layout); | |
| 253 | 261 | if (IS_ERR(hw)) |
| 254 | 262 | goto err_free; |
| 255 | 263 | } |
| @@ -362,7 +362,7 @@ struct clk *imx_clk_pll14xx(const char *name, const char *parent_name, · 361 unmodified lines | ||
| 362 | 362 | |
| 363 | 363 | switch (pll_clk->type) { |
| 364 | 364 | case PLL_1416X: |
| 365 | − if (!pll->rate_table) | |
| 365 | + if (!pll_clk->rate_table) | |
| 366 | 366 | init.ops = &clk_pll1416x_min_ops; |
| 367 | 367 | else |
| 368 | 368 | init.ops = &clk_pll1416x_ops; |
| @@ -169,11 +169,10 @@ struct clk *mtk_clk_register_gate( · 168 unmodified lines | ||
| 169 | 169 | return ERR_PTR(-ENOMEM); |
| 170 | 170 | |
| 171 | 171 | init.name = name; |
| 172 | − init.flags = CLK_SET_RATE_PARENT; | |
| 172 | + init.flags = flags | CLK_SET_RATE_PARENT; | |
| 173 | 173 | init.parent_names = parent_name ? &parent_name : NULL; |
| 174 | 174 | init.num_parents = parent_name ? 1 : 0; |
| 175 | 175 | init.ops = ops; |
| 176 | − init.flags = flags; | |
| 177 | 176 | |
| 178 | 177 | cg->regmap = regmap; |
| 179 | 178 | cg->set_ofs = set_ofs; |
| @@ -120,7 +120,7 @@ static bool meson_clk_pll_is_better(unsigned long rate, · 119 unmodified lines | ||
| 120 | 120 | return true; |
| 121 | 121 | } else { |
| 122 | 122 | /* Round down */ |
| 123 | − if (now < rate && best < now) | |
| 123 | + if (now <= rate && best < now) | |
| 124 | 124 | return true; |
| 125 | 125 | } |
| 126 | 126 | |
| @@ -960,14 +960,14 @@ static struct clk_regmap g12a_sd_emmc_c_clk0 = { · 959 unmodified lines | ||
| 960 | 960 | /* VPU Clock */ |
| 961 | 961 | |
| 962 | 962 | static const char * const g12a_vpu_parent_names[] = { |
| 963 | − "fclk_div4", "fclk_div3", "fclk_div5", "fclk_div7", | |
| 963 | + "fclk_div3", "fclk_div4", "fclk_div5", "fclk_div7", | |
| 964 | 964 | "mpll1", "vid_pll", "hifi_pll", "gp0_pll", |
| 965 | 965 | }; |
| 966 | 966 | |
| 967 | 967 | static struct clk_regmap g12a_vpu_0_sel = { |
| 968 | 968 | .data = &(struct clk_regmap_mux_data){ |
| 969 | 969 | .offset = HHI_VPU_CLK_CNTL, |
| 970 | − .mask = 0x3, | |
| 970 | + .mask = 0x7, | |
| 971 | 971 | .shift = 9, |
| 972 | 972 | }, |
| 973 | 973 | .hw.init = &(struct clk_init_data){ |
| @@ -1011,7 +1011,7 @@ static struct clk_regmap g12a_vpu_0 = { · 37 unmodified lines | ||
| 1011 | 1011 | static struct clk_regmap g12a_vpu_1_sel = { |
| 1012 | 1012 | .data = &(struct clk_regmap_mux_data){ |
| 1013 | 1013 | .offset = HHI_VPU_CLK_CNTL, |
| 1014 | − .mask = 0x3, | |
| 1014 | + .mask = 0x7, | |
| 1015 | 1015 | .shift = 25, |
| 1016 | 1016 | }, |
| 1017 | 1017 | .hw.init = &(struct clk_init_data){ |
| @@ -2216,6 +2216,7 @@ static struct clk_regmap gxbb_vdec_1_div = { · 2215 unmodified lines | ||
| 2216 | 2216 | .offset = HHI_VDEC_CLK_CNTL, |
| 2217 | 2217 | .shift = 0, |
| 2218 | 2218 | .width = 7, |
| 2219 | + .flags = CLK_DIVIDER_ROUND_CLOSEST, | |
| 2219 | 2220 | }, |
| 2220 | 2221 | .hw.init = &(struct clk_init_data){ |
| 2221 | 2222 | .name = "vdec_1_div", |
| @@ -2261,6 +2262,7 @@ static struct clk_regmap gxbb_vdec_hevc_div = { · 39 unmodified lines | ||
| 2261 | 2262 | .offset = HHI_VDEC2_CLK_CNTL, |
| 2262 | 2263 | .shift = 16, |
| 2263 | 2264 | .width = 7, |
| 2265 | + .flags = CLK_DIVIDER_ROUND_CLOSEST, | |
| 2264 | 2266 | }, |
| 2265 | 2267 | .hw.init = &(struct clk_init_data){ |
| 2266 | 2268 | .name = "vdec_hevc_div", |
| @@ -82,8 +82,8 @@ static unsigned long meson_vid_pll_div_recalc_rate(struct clk_hw *hw, · 81 unmodified lines | ||
| 82 | 82 | div = _get_table_val(meson_parm_read(clk->map, &pll_div->val), |
| 83 | 83 | meson_parm_read(clk->map, &pll_div->sel)); |
| 84 | 84 | if (!div || !div->divider) { |
| 85 | − pr_info("%s: Invalid config value for vid_pll_div\n", __func__); | |
| 86 | − return parent_rate; | |
| 85 | + pr_debug("%s: Invalid config value for vid_pll_div\n", __func__); | |
| 86 | + return 0; | |
| 87 | 87 | } |
| 88 | 88 | |
| 89 | 89 | return DIV_ROUND_UP_ULL(parent_rate * div->multiplier, div->divider); |
| @@ -165,7 +165,7 @@ static const struct clk_ops plt_clk_ops = { · 164 unmodified lines | ||
| 165 | 165 | }; |
| 166 | 166 | |
| 167 | 167 | static struct clk_plt *plt_clk_register(struct platform_device *pdev, int id, |
| 168 | − void __iomem *base, | |
| 168 | + const struct pmc_clk_data *pmc_data, | |
| 169 | 169 | const char **parent_names, |
| 170 | 170 | int num_parents) |
| 171 | 171 | { |
| @@ -184,9 +184,17 @@ static struct clk_plt *plt_clk_register(struct platform_device *pdev, int id, · 12 unmodified lines | ||
| 184 | 184 | init.num_parents = num_parents; |
| 185 | 185 | |
| 186 | 186 | pclk->hw.init = &init; |
| 187 | − pclk->reg = base + PMC_CLK_CTL_OFFSET + id * PMC_CLK_CTL_SIZE; | |
| 187 | + pclk->reg = pmc_data->base + PMC_CLK_CTL_OFFSET + id * PMC_CLK_CTL_SIZE; | |
| 188 | 188 | spin_lock_init(&pclk->lock); |
| 189 | 189 | |
| 190 | + /* | |
| 191 | + * On some systems, the pmc_plt_clocks already enabled by the | |
| 192 | + * firmware are being marked as critical to avoid them being | |
| 193 | + * gated by the clock framework. | |
| 194 | + */ | |
| 195 | + if (pmc_data->critical && plt_clk_is_enabled(&pclk->hw)) | |
| 196 | + init.flags |= CLK_IS_CRITICAL; | |
| 197 | + | |
| 190 | 198 | ret = devm_clk_hw_register(&pdev->dev, &pclk->hw); |
| 191 | 199 | if (ret) { |
| 192 | 200 | pclk = ERR_PTR(ret); |
| @@ -332,7 +340,7 @@ static int plt_clk_probe(struct platform_device *pdev) · 139 unmodified lines | ||
| 332 | 340 | return PTR_ERR(parent_names); |
| 333 | 341 | |
| 334 | 342 | for (i = 0; i < PMC_CLK_NUM; i++) { |
| 335 | − data->clks[i] = plt_clk_register(pdev, i, pmc_data->base, | |
| 343 | + data->clks[i] = plt_clk_register(pdev, i, pmc_data, | |
| 336 | 344 | parent_names, data->nparents); |
| 337 | 345 | if (IS_ERR(data->clks[i])) { |
| 338 | 346 | err = PTR_ERR(data->clks[i]); |
| @@ -3173,11 +3173,16 @@ static int amdgpu_device_recover_vram(struct amdgpu_device *adev) · 3172 unmodified lines | ||
| 3173 | 3173 | break; |
| 3174 | 3174 | |
| 3175 | 3175 | if (fence) { |
| 3176 | − r = dma_fence_wait_timeout(fence, false, tmo); | |
| 3176 | + tmo = dma_fence_wait_timeout(fence, false, tmo); | |
| 3177 | 3177 | dma_fence_put(fence); |
| 3178 | 3178 | fence = next; |
| 3179 | − if (r <= 0) | |
| 3179 | + if (tmo == 0) { | |
| 3180 | + r = -ETIMEDOUT; | |
| 3180 | 3181 | break; |
| 3182 | + } else if (tmo < 0) { | |
| 3183 | + r = tmo; | |
| 3184 | + break; | |
| 3185 | + } | |
| 3181 | 3186 | } else { |
| 3182 | 3187 | fence = next; |
| 3183 | 3188 | } |
| @@ -3188,8 +3193,8 @@ static int amdgpu_device_recover_vram(struct amdgpu_device *adev) · 4 unmodified lines | ||
| 3188 | 3193 | tmo = dma_fence_wait_timeout(fence, false, tmo); |
| 3189 | 3194 | dma_fence_put(fence); |
| 3190 | 3195 | |
| 3191 | − if (r <= 0 || tmo <= 0) { | |
| 3192 | − DRM_ERROR("recover vram bo from shadow failed\n"); | |
| 3196 | + if (r < 0 || tmo <= 0) { | |
| 3197 | + DRM_ERROR("recover vram bo from shadow failed, r is %ld, tmo is %ld\n", r, tmo); | |
| 3193 | 3198 | return -EIO; |
| 3194 | 3199 | } |
| 3195 | 3200 | |
| @@ -35,6 +35,7 @@ · 34 unmodified lines | ||
| 35 | 35 | #include "amdgpu_trace.h" |
| 36 | 36 | |
| 37 | 37 | #define AMDGPU_IB_TEST_TIMEOUT msecs_to_jiffies(1000) |
| 38 | +#define AMDGPU_IB_TEST_GFX_XGMI_TIMEOUT msecs_to_jiffies(2000) | |
| 38 | 39 | |
| 39 | 40 | /* |
| 40 | 41 | * IB |
| @@ -344,6 +345,8 @@ int amdgpu_ib_ring_tests(struct amdgpu_device *adev) · 303 unmodified lines | ||
| 344 | 345 | * cost waiting for it coming back under RUNTIME only |
| 345 | 346 | */ |
| 346 | 347 | tmo_gfx = 8 * AMDGPU_IB_TEST_TIMEOUT; |
| 348 | + } else if (adev->gmc.xgmi.hive_id) { | |
| 349 | + tmo_gfx = AMDGPU_IB_TEST_GFX_XGMI_TIMEOUT; | |
| 347 | 350 | } |
| 348 | 351 | |
| 349 | 352 | for (i = 0; i < adev->num_rings; ++i) { |
| @@ -320,6 +320,7 @@ static const struct kfd_deviceid supported_devices[] = { · 319 unmodified lines | ||
| 320 | 320 | { 0x9876, &carrizo_device_info }, /* Carrizo */ |
| 321 | 321 | { 0x9877, &carrizo_device_info }, /* Carrizo */ |
| 322 | 322 | { 0x15DD, &raven_device_info }, /* Raven */ |
| 323 | + { 0x15D8, &raven_device_info }, /* Raven */ | |
| 323 | 324 | #endif |
| 324 | 325 | { 0x67A0, &hawaii_device_info }, /* Hawaii */ |
| 325 | 326 | { 0x67A1, &hawaii_device_info }, /* Hawaii */ |
| @@ -4533,6 +4533,7 @@ static void handle_cursor_update(struct drm_plane *plane, · 4532 unmodified lines | ||
| 4533 | 4533 | amdgpu_crtc->cursor_width = plane->state->crtc_w; |
| 4534 | 4534 | amdgpu_crtc->cursor_height = plane->state->crtc_h; |
| 4535 | 4535 | |
| 4536 | + memset(&attributes, 0, sizeof(attributes)); | |
| 4536 | 4537 | attributes.address.high_part = upper_32_bits(address); |
| 4537 | 4538 | attributes.address.low_part = lower_32_bits(address); |
| 4538 | 4539 | attributes.width = plane->state->crtc_w; |
| @@ -1150,28 +1150,9 @@ void hubp1_cursor_set_position( · 1149 unmodified lines | ||
| 1150 | 1150 | REG_UPDATE(CURSOR_CONTROL, |
| 1151 | 1151 | CURSOR_ENABLE, cur_en); |
| 1152 | 1152 | |
| 1153 | − //account for cases where we see negative offset relative to overlay plane | |
| 1154 | − if (src_x_offset < 0 && src_y_offset < 0) { | |
| 1155 | − REG_SET_2(CURSOR_POSITION, 0, | |
| 1156 | − CURSOR_X_POSITION, 0, | |
| 1157 | − CURSOR_Y_POSITION, 0); | |
| 1158 | − x_hotspot -= src_x_offset; | |
| 1159 | − y_hotspot -= src_y_offset; | |
| 1160 | − } else if (src_x_offset < 0) { | |
| 1161 | − REG_SET_2(CURSOR_POSITION, 0, | |
| 1162 | − CURSOR_X_POSITION, 0, | |
| 1163 | − CURSOR_Y_POSITION, pos->y); | |
| 1164 | − x_hotspot -= src_x_offset; | |
| 1165 | − } else if (src_y_offset < 0) { | |
| 1166 | − REG_SET_2(CURSOR_POSITION, 0, | |
| 1153 | + REG_SET_2(CURSOR_POSITION, 0, | |
| 1167 | 1154 | CURSOR_X_POSITION, pos->x, |
| 1168 | − CURSOR_Y_POSITION, 0); | |
| 1169 | − y_hotspot -= src_y_offset; | |
| 1170 | − } else { | |
| 1171 | − REG_SET_2(CURSOR_POSITION, 0, | |
| 1172 | − CURSOR_X_POSITION, pos->x, | |
| 1173 | − CURSOR_Y_POSITION, pos->y); | |
| 1174 | − } | |
| 1155 | + CURSOR_Y_POSITION, pos->y); | |
| 1175 | 1156 | |
| 1176 | 1157 | REG_SET_2(CURSOR_HOT_SPOT, 0, |
| 1177 | 1158 | CURSOR_HOT_SPOT_X, x_hotspot, |
| @@ -1037,6 +1037,31 @@ void dw_hdmi_phy_i2c_write(struct dw_hdmi *hdmi, unsigned short data, · 1036 unmodified lines | ||
| 1037 | 1037 | } |
| 1038 | 1038 | EXPORT_SYMBOL_GPL(dw_hdmi_phy_i2c_write); |
| 1039 | 1039 | |
| 1040 | +/* Filter out invalid setups to avoid configuring SCDC and scrambling */ | |
| 1041 | +static bool dw_hdmi_support_scdc(struct dw_hdmi *hdmi) | |
| 1042 | +{ | |
| 1043 | + struct drm_display_info *display = &hdmi->connector.display_info; | |
| 1044 | + | |
| 1045 | + /* Completely disable SCDC support for older controllers */ | |
| 1046 | + if (hdmi->version < 0x200a) | |
| 1047 | + return false; | |
| 1048 | + | |
| 1049 | + /* Disable if SCDC is not supported, or if an HF-VSDB block is absent */ | |
| 1050 | + if (!display->hdmi.scdc.supported || | |
| 1051 | + !display->hdmi.scdc.scrambling.supported) | |
| 1052 | + return false; | |
| 1053 | + | |
| 1054 | + /* | |
| 1055 | + * Disable if display only support low TMDS rates and scrambling | |
| 1056 | + * for low rates is not supported either | |
| 1057 | + */ | |
| 1058 | + if (!display->hdmi.scdc.scrambling.low_rates && | |
| 1059 | + display->max_tmds_clock <= 340000) | |
| 1060 | + return false; | |
| 1061 | + | |
| 1062 | + return true; | |
| 1063 | +} | |
| 1064 | + | |
| 1040 | 1065 | /* |
| 1041 | 1066 | * HDMI2.0 Specifies the following procedure for High TMDS Bit Rates: |
| 1042 | 1067 | * - The Source shall suspend transmission of the TMDS clock and data |
| @@ -1055,7 +1080,7 @@ void dw_hdmi_set_high_tmds_clock_ratio(struct dw_hdmi *hdmi) · 12 unmodified lines | ||
| 1055 | 1080 | unsigned long mtmdsclock = hdmi->hdmi_data.video_mode.mtmdsclock; |
| 1056 | 1081 | |
| 1057 | 1082 | /* Control for TMDS Bit Period/TMDS Clock-Period Ratio */ |
| 1058 | − if (hdmi->connector.display_info.hdmi.scdc.supported) { | |
| 1083 | + if (dw_hdmi_support_scdc(hdmi)) { | |
| 1059 | 1084 | if (mtmdsclock > HDMI14_MAX_TMDSCLK) |
| 1060 | 1085 | drm_scdc_set_high_tmds_clock_ratio(hdmi->ddc, 1); |
| 1061 | 1086 | else |
| @@ -1579,8 +1604,9 @@ static void hdmi_av_composer(struct dw_hdmi *hdmi, · 517 unmodified lines | ||
| 1579 | 1604 | |
| 1580 | 1605 | /* Set up HDMI_FC_INVIDCONF */ |
| 1581 | 1606 | inv_val = (hdmi->hdmi_data.hdcp_enable || |
| 1582 | − vmode->mtmdsclock > HDMI14_MAX_TMDSCLK || | |
| 1583 | − hdmi_info->scdc.scrambling.low_rates ? | |
| 1607 | + (dw_hdmi_support_scdc(hdmi) && | |
| 1608 | + (vmode->mtmdsclock > HDMI14_MAX_TMDSCLK || | |
| 1609 | + hdmi_info->scdc.scrambling.low_rates)) ? | |
| 1584 | 1610 | HDMI_FC_INVIDCONF_HDCP_KEEPOUT_ACTIVE : |
| 1585 | 1611 | HDMI_FC_INVIDCONF_HDCP_KEEPOUT_INACTIVE); |
| 1586 | 1612 | |
| @@ -1646,7 +1672,7 @@ static void hdmi_av_composer(struct dw_hdmi *hdmi, · 59 unmodified lines | ||
| 1646 | 1672 | } |
| 1647 | 1673 | |
| 1648 | 1674 | /* Scrambling Control */ |
| 1649 | − if (hdmi_info->scdc.supported) { | |
| 1675 | + if (dw_hdmi_support_scdc(hdmi)) { | |
| 1650 | 1676 | if (vmode->mtmdsclock > HDMI14_MAX_TMDSCLK || |
| 1651 | 1677 | hdmi_info->scdc.scrambling.low_rates) { |
| 1652 | 1678 | /* |
| @@ -1034,7 +1034,7 @@ disable_outputs(struct drm_device *dev, struct drm_atomic_state *old_state) · 1033 unmodified lines | ||
| 1034 | 1034 | funcs->atomic_disable(crtc, old_crtc_state); |
| 1035 | 1035 | else if (funcs->disable) |
| 1036 | 1036 | funcs->disable(crtc); |
| 1037 | − else | |
| 1037 | + else if (funcs->dpms) | |
| 1038 | 1038 | funcs->dpms(crtc, DRM_MODE_DPMS_OFF); |
| 1039 | 1039 | |
| 1040 | 1040 | if (!(dev->irq_enabled && dev->num_crtcs)) |
| @@ -1277,10 +1277,9 @@ void drm_atomic_helper_commit_modeset_enables(struct drm_device *dev, · 236 unmodified lines | ||
| 1277 | 1277 | if (new_crtc_state->enable) { |
| 1278 | 1278 | DRM_DEBUG_ATOMIC("enabling [CRTC:%d:%s]\n", |
| 1279 | 1279 | crtc->base.id, crtc->name); |
| 1280 | − | |
| 1281 | 1280 | if (funcs->atomic_enable) |
| 1282 | 1281 | funcs->atomic_enable(crtc, old_crtc_state); |
| 1283 | − else | |
| 1282 | + else if (funcs->commit) | |
| 1284 | 1283 | funcs->commit(crtc); |
| 1285 | 1284 | } |
| 1286 | 1285 | } |
| @@ -209,7 +209,7 @@ static int vgpu_get_plane_info(struct drm_device *dev, · 208 unmodified lines | ||
| 209 | 209 | struct drm_i915_private *dev_priv = to_i915(dev); |
| 210 | 210 | struct intel_vgpu_primary_plane_format p; |
| 211 | 211 | struct intel_vgpu_cursor_plane_format c; |
| 212 | − int ret; | |
| 212 | + int ret, tile_height = 1; | |
| 213 | 213 | |
| 214 | 214 | if (plane_id == DRM_PLANE_TYPE_PRIMARY) { |
| 215 | 215 | ret = intel_vgpu_decode_primary_plane(vgpu, &p); |
| @@ -228,12 +228,15 @@ static int vgpu_get_plane_info(struct drm_device *dev, · 12 unmodified lines | ||
| 228 | 228 | break; |
| 229 | 229 | case PLANE_CTL_TILED_X: |
| 230 | 230 | info->drm_format_mod = I915_FORMAT_MOD_X_TILED; |
| 231 | + tile_height = 8; | |
| 231 | 232 | break; |
| 232 | 233 | case PLANE_CTL_TILED_Y: |
| 233 | 234 | info->drm_format_mod = I915_FORMAT_MOD_Y_TILED; |
| 235 | + tile_height = 32; | |
| 234 | 236 | break; |
| 235 | 237 | case PLANE_CTL_TILED_YF: |
| 236 | 238 | info->drm_format_mod = I915_FORMAT_MOD_Yf_TILED; |
| 239 | + tile_height = 32; | |
| 237 | 240 | break; |
| 238 | 241 | default: |
| 239 | 242 | gvt_vgpu_err("invalid tiling mode: %x\n", p.tiled); |
| @@ -264,8 +267,8 @@ static int vgpu_get_plane_info(struct drm_device *dev, · 24 unmodified lines | ||
| 264 | 267 | return -EINVAL; |
| 265 | 268 | } |
| 266 | 269 | |
| 267 | − info->size = (info->stride * info->height + PAGE_SIZE - 1) | |
| 268 | − >> PAGE_SHIFT; | |
| 270 | + info->size = (info->stride * roundup(info->height, tile_height) | |
| 271 | + + PAGE_SIZE - 1) >> PAGE_SHIFT; | |
| 269 | 272 | if (info->size == 0) { |
| 270 | 273 | gvt_vgpu_err("fb size is zero\n"); |
| 271 | 274 | return -EINVAL; |
| @@ -750,14 +750,20 @@ static void ppgtt_free_spt(struct intel_vgpu_ppgtt_spt *spt) · 749 unmodified lines | ||
| 750 | 750 | |
| 751 | 751 | static void ppgtt_free_all_spt(struct intel_vgpu *vgpu) |
| 752 | 752 | { |
| 753 | − struct intel_vgpu_ppgtt_spt *spt; | |
| 753 | + struct intel_vgpu_ppgtt_spt *spt, *spn; | |
| 754 | 754 | struct radix_tree_iter iter; |
| 755 | − void **slot; | |
| 755 | + LIST_HEAD(all_spt); | |
| 756 | + void __rcu **slot; | |
| 756 | 757 | |
| 758 | + rcu_read_lock(); | |
| 757 | 759 | radix_tree_for_each_slot(slot, &vgpu->gtt.spt_tree, &iter, 0) { |
| 758 | 760 | spt = radix_tree_deref_slot(slot); |
| 759 | − ppgtt_free_spt(spt); | |
| 761 | + list_move(&spt->post_shadow_list, &all_spt); | |
| 760 | 762 | } |
| 763 | + rcu_read_unlock(); | |
| 764 | + | |
| 765 | + list_for_each_entry_safe(spt, spn, &all_spt, post_shadow_list) | |
| 766 | + ppgtt_free_spt(spt); | |
| 761 | 767 | } |
| 762 | 768 | |
| 763 | 769 | static int ppgtt_handle_guest_write_page_table_bytes( |
| @@ -905,7 +905,7 @@ static inline bool intel_vgpu_in_aperture(struct intel_vgpu *vgpu, u64 off) · 904 unmodified lines | ||
| 905 | 905 | static int intel_vgpu_aperture_rw(struct intel_vgpu *vgpu, u64 off, |
| 906 | 906 | void *buf, unsigned long count, bool is_write) |
| 907 | 907 | { |
| 908 | − void *aperture_va; | |
| 908 | + void __iomem *aperture_va; | |
| 909 | 909 | |
| 910 | 910 | if (!intel_vgpu_in_aperture(vgpu, off) || |
| 911 | 911 | !intel_vgpu_in_aperture(vgpu, off + count)) { |
| @@ -920,9 +920,9 @@ static int intel_vgpu_aperture_rw(struct intel_vgpu *vgpu, u64 off, · 8 unmodified lines | ||
| 920 | 920 | return -EIO; |
| 921 | 921 | |
| 922 | 922 | if (is_write) |
| 923 | − memcpy(aperture_va + offset_in_page(off), buf, count); | |
| 923 | + memcpy_toio(aperture_va + offset_in_page(off), buf, count); | |
| 924 | 924 | else |
| 925 | − memcpy(buf, aperture_va + offset_in_page(off), count); | |
| 925 | + memcpy_fromio(buf, aperture_va + offset_in_page(off), count); | |
| 926 | 926 | |
| 927 | 927 | io_mapping_unmap(aperture_va); |
| 928 | 928 | |
| @@ -323,6 +323,21 @@ static void gen11_dsi_program_esc_clk_div(struct intel_encoder *encoder) · 322 unmodified lines | ||
| 323 | 323 | } |
| 324 | 324 | } |
| 325 | 325 | |
| 326 | +static void get_dsi_io_power_domains(struct drm_i915_private *dev_priv, | |
| 327 | + struct intel_dsi *intel_dsi) | |
| 328 | +{ | |
| 329 | + enum port port; | |
| 330 | + | |
| 331 | + for_each_dsi_port(port, intel_dsi->ports) { | |
| 332 | + WARN_ON(intel_dsi->io_wakeref[port]); | |
| 333 | + intel_dsi->io_wakeref[port] = | |
| 334 | + intel_display_power_get(dev_priv, | |
| 335 | + port == PORT_A ? | |
| 336 | + POWER_DOMAIN_PORT_DDI_A_IO : | |
| 337 | + POWER_DOMAIN_PORT_DDI_B_IO); | |
| 338 | + } | |
| 339 | +} | |
| 340 | + | |
| 326 | 341 | static void gen11_dsi_enable_io_power(struct intel_encoder *encoder) |
| 327 | 342 | { |
| 328 | 343 | struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); |
| @@ -336,13 +351,7 @@ static void gen11_dsi_enable_io_power(struct intel_encoder *encoder) · 7 unmodified lines | ||
| 336 | 351 | I915_WRITE(ICL_DSI_IO_MODECTL(port), tmp); |
| 337 | 352 | } |
| 338 | 353 | |
| 339 | − for_each_dsi_port(port, intel_dsi->ports) { | |
| 340 | − intel_dsi->io_wakeref[port] = | |
| 341 | − intel_display_power_get(dev_priv, | |
| 342 | − port == PORT_A ? | |
| 343 | − POWER_DOMAIN_PORT_DDI_A_IO : | |
| 344 | − POWER_DOMAIN_PORT_DDI_B_IO); | |
| 345 | − } | |
| 354 | + get_dsi_io_power_domains(dev_priv, intel_dsi); | |
| 346 | 355 | } |
| 347 | 356 | |
| 348 | 357 | static void gen11_dsi_power_up_lanes(struct intel_encoder *encoder) |
| @@ -589,6 +598,12 @@ static void gen11_dsi_map_pll(struct intel_encoder *encoder, · 240 unmodified lines | ||
| 589 | 598 | val |= DPCLKA_CFGCR0_DDI_CLK_SEL(pll->info->id, port); |
| 590 | 599 | } |
| 591 | 600 | I915_WRITE(DPCLKA_CFGCR0_ICL, val); |
| 601 | + | |
| 602 | + for_each_dsi_port(port, intel_dsi->ports) { | |
| 603 | + val &= ~DPCLKA_CFGCR0_DDI_CLK_OFF(port); | |
| 604 | + } | |
| 605 | + I915_WRITE(DPCLKA_CFGCR0_ICL, val); | |
| 606 | + | |
| 592 | 607 | POSTING_READ(DPCLKA_CFGCR0_ICL); |
| 593 | 608 | |
| 594 | 609 | mutex_unlock(&dev_priv->dpll_lock); |
| @@ -1117,7 +1132,7 @@ static void gen11_dsi_disable_port(struct intel_encoder *encoder) · 522 unmodified lines | ||
| 1117 | 1132 | DRM_ERROR("DDI port:%c buffer not idle\n", |
| 1118 | 1133 | port_name(port)); |
| 1119 | 1134 | } |
| 1120 | − gen11_dsi_ungate_clocks(encoder); | |
| 1135 | + gen11_dsi_gate_clocks(encoder); | |
| 1121 | 1136 | } |
| 1122 | 1137 | |
| 1123 | 1138 | static void gen11_dsi_disable_io_power(struct intel_encoder *encoder) |
| @@ -1218,20 +1233,11 @@ static int gen11_dsi_compute_config(struct intel_encoder *encoder, · 94 unmodified lines | ||
| 1218 | 1233 | return 0; |
| 1219 | 1234 | } |
| 1220 | 1235 | |
| 1221 | −static u64 gen11_dsi_get_power_domains(struct intel_encoder *encoder, | |
| 1222 | − struct intel_crtc_state *crtc_state) | |
| 1236 | +static void gen11_dsi_get_power_domains(struct intel_encoder *encoder, | |
| 1237 | + struct intel_crtc_state *crtc_state) | |
| 1223 | 1238 | { |
| 1224 | − struct intel_dsi *intel_dsi = enc_to_intel_dsi(&encoder->base); | |
| 1225 | − u64 domains = 0; | |
| 1226 | − enum port port; | |
| 1227 | − | |
| 1228 | − for_each_dsi_port(port, intel_dsi->ports) | |
| 1229 | − if (port == PORT_A) | |
| 1230 | − domains |= BIT_ULL(POWER_DOMAIN_PORT_DDI_A_IO); | |
| 1231 | − else | |
| 1232 | − domains |= BIT_ULL(POWER_DOMAIN_PORT_DDI_B_IO); | |
| 1233 | − | |
| 1234 | − return domains; | |
| 1239 | + get_dsi_io_power_domains(to_i915(encoder->base.dev), | |
| 1240 | + enc_to_intel_dsi(&encoder->base)); | |
| 1235 | 1241 | } |
| 1236 | 1242 | |
| 1237 | 1243 | static bool gen11_dsi_get_hw_state(struct intel_encoder *encoder, |
| @@ -2075,12 +2075,11 @@ intel_ddi_main_link_aux_domain(struct intel_digital_port *dig_port) · 2074 unmodified lines | ||
| 2075 | 2075 | intel_aux_power_domain(dig_port); |
| 2076 | 2076 | } |
| 2077 | 2077 | |
| 2078 | −static u64 intel_ddi_get_power_domains(struct intel_encoder *encoder, | |
| 2079 | − struct intel_crtc_state *crtc_state) | |
| 2078 | +static void intel_ddi_get_power_domains(struct intel_encoder *encoder, | |
| 2079 | + struct intel_crtc_state *crtc_state) | |
| 2080 | 2080 | { |
| 2081 | 2081 | struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); |
| 2082 | 2082 | struct intel_digital_port *dig_port; |
| 2083 | − u64 domains; | |
| 2084 | 2083 | |
| 2085 | 2084 | /* |
| 2086 | 2085 | * TODO: Add support for MST encoders. Atm, the following should never |
| @@ -2088,10 +2087,10 @@ static u64 intel_ddi_get_power_domains(struct intel_encoder *encoder, · 1 unmodified line | ||
| 2088 | 2087 | * hook. |
| 2089 | 2088 | */ |
| 2090 | 2089 | if (WARN_ON(intel_crtc_has_type(crtc_state, INTEL_OUTPUT_DP_MST))) |
| 2091 | − return 0; | |
| 2090 | + return; | |
| 2092 | 2091 | |
| 2093 | 2092 | dig_port = enc_to_dig_port(&encoder->base); |
| 2094 | − domains = BIT_ULL(dig_port->ddi_io_power_domain); | |
| 2093 | + intel_display_power_get(dev_priv, dig_port->ddi_io_power_domain); | |
| 2095 | 2094 | |
| 2096 | 2095 | /* |
| 2097 | 2096 | * AUX power is only needed for (e)DP mode, and for HDMI mode on TC |
| @@ -2099,15 +2098,15 @@ static u64 intel_ddi_get_power_domains(struct intel_encoder *encoder, · 1 unmodified line | ||
| 2099 | 2098 | */ |
| 2100 | 2099 | if (intel_crtc_has_dp_encoder(crtc_state) || |
| 2101 | 2100 | intel_port_is_tc(dev_priv, encoder->port)) |
| 2102 | − domains |= BIT_ULL(intel_ddi_main_link_aux_domain(dig_port)); | |
| 2101 | + intel_display_power_get(dev_priv, | |
| 2102 | + intel_ddi_main_link_aux_domain(dig_port)); | |
| 2103 | 2103 | |
| 2104 | 2104 | /* |
| 2105 | 2105 | * VDSC power is needed when DSC is enabled |
| 2106 | 2106 | */ |
| 2107 | 2107 | if (crtc_state->dsc_params.compression_enable) |
| 2108 | − domains |= BIT_ULL(intel_dsc_power_domain(crtc_state)); | |
| 2109 | − | |
| 2110 | − return domains; | |
| 2108 | + intel_display_power_get(dev_priv, | |
| 2109 | + intel_dsc_power_domain(crtc_state)); | |
| 2111 | 2110 | } |
| 2112 | 2111 | |
| 2113 | 2112 | void intel_ddi_enable_pipe_clock(const struct intel_crtc_state *crtc_state) |
| @@ -2825,10 +2824,10 @@ void icl_sanitize_encoder_pll_mapping(struct intel_encoder *encoder) · 711 unmodified lines | ||
| 2825 | 2824 | return; |
| 2826 | 2825 | } |
| 2827 | 2826 | /* |
| 2828 | − * DSI ports should have their DDI clock ungated when disabled | |
| 2829 | − * and gated when enabled. | |
| 2827 | + * For DSI we keep the ddi clocks gated | |
| 2828 | + * except during enable/disable sequence. | |
| 2830 | 2829 | */ |
| 2831 | − ddi_clk_needed = !encoder->base.crtc; | |
| 2830 | + ddi_clk_needed = false; | |
| 2832 | 2831 | } |
| 2833 | 2832 | |
| 2834 | 2833 | val = I915_READ(DPCLKA_CFGCR0_ICL); |
| @@ -15986,8 +15986,6 @@ get_encoder_power_domains(struct drm_i915_private *dev_priv) · 15985 unmodified lines | ||
| 15986 | 15986 | struct intel_encoder *encoder; |
| 15987 | 15987 | |
| 15988 | 15988 | for_each_intel_encoder(&dev_priv->drm, encoder) { |
| 15989 | − u64 get_domains; | |
| 15990 | − enum intel_display_power_domain domain; | |
| 15991 | 15989 | struct intel_crtc_state *crtc_state; |
| 15992 | 15990 | |
| 15993 | 15991 | if (!encoder->get_power_domains) |
| @@ -16001,9 +15999,7 @@ get_encoder_power_domains(struct drm_i915_private *dev_priv) · 7 unmodified lines | ||
| 16001 | 15999 | continue; |
| 16002 | 16000 | |
| 16003 | 16001 | crtc_state = to_intel_crtc_state(encoder->base.crtc->state); |
| 16004 | − get_domains = encoder->get_power_domains(encoder, crtc_state); | |
| 16005 | − for_each_power_domain(domain, get_domains) | |
| 16006 | − intel_display_power_get(dev_priv, domain); | |
| 16002 | + encoder->get_power_domains(encoder, crtc_state); | |
| 16007 | 16003 | } |
| 16008 | 16004 | } |
| 16009 | 16005 | |
| @@ -1859,42 +1859,6 @@ intel_dp_compute_link_config_wide(struct intel_dp *intel_dp, · 1858 unmodified lines | ||
| 1859 | 1859 | return -EINVAL; |
| 1860 | 1860 | } |
| 1861 | 1861 | |
| 1862 | −/* Optimize link config in order: max bpp, min lanes, min clock */ | |
| 1863 | −static int | |
| 1864 | −intel_dp_compute_link_config_fast(struct intel_dp *intel_dp, | |
| 1865 | − struct intel_crtc_state *pipe_config, | |
| 1866 | − const struct link_config_limits *limits) | |
| 1867 | −{ | |
| 1868 | − struct drm_display_mode *adjusted_mode = &pipe_config->base.adjusted_mode; | |
| 1869 | − int bpp, clock, lane_count; | |
| 1870 | − int mode_rate, link_clock, link_avail; | |
| 1871 | − | |
| 1872 | − for (bpp = limits->max_bpp; bpp >= limits->min_bpp; bpp -= 2 * 3) { | |
| 1873 | − mode_rate = intel_dp_link_required(adjusted_mode->crtc_clock, | |
| 1874 | − bpp); | |
| 1875 | − | |
| 1876 | − for (lane_count = limits->min_lane_count; | |
| 1877 | − lane_count <= limits->max_lane_count; | |
| 1878 | − lane_count <<= 1) { | |
| 1879 | − for (clock = limits->min_clock; clock <= limits->max_clock; clock++) { | |
| 1880 | − link_clock = intel_dp->common_rates[clock]; | |
| 1881 | − link_avail = intel_dp_max_data_rate(link_clock, | |
| 1882 | − lane_count); | |
| 1883 | − | |
| 1884 | − if (mode_rate <= link_avail) { | |
| 1885 | − pipe_config->lane_count = lane_count; | |
| 1886 | − pipe_config->pipe_bpp = bpp; | |
| 1887 | − pipe_config->port_clock = link_clock; | |
| 1888 | − | |
| 1889 | − return 0; | |
| 1890 | − } | |
| 1891 | − } | |
| 1892 | − } | |
| 1893 | − } | |
| 1894 | − | |
| 1895 | − return -EINVAL; | |
| 1896 | −} | |
| 1897 | − | |
| 1898 | 1862 | static int intel_dp_dsc_compute_bpp(struct intel_dp *intel_dp, u8 dsc_max_bpc) |
| 1899 | 1863 | { |
| 1900 | 1864 | int i, num_bpc; |
| @@ -2031,15 +1995,13 @@ intel_dp_compute_link_config(struct intel_encoder *encoder, · 130 unmodified lines | ||
| 2031 | 1995 | limits.min_bpp = 6 * 3; |
| 2032 | 1996 | limits.max_bpp = intel_dp_compute_bpp(intel_dp, pipe_config); |
| 2033 | 1997 | |
| 2034 | − if (intel_dp_is_edp(intel_dp) && intel_dp->edp_dpcd[0] < DP_EDP_14) { | |
| 1998 | + if (intel_dp_is_edp(intel_dp)) { | |
| 2035 | 1999 | /* |
| 2036 | 2000 | * Use the maximum clock and number of lanes the eDP panel |
| 2037 | − * advertizes being capable of. The eDP 1.3 and earlier panels | |
| 2038 | − * are generally designed to support only a single clock and | |
| 2039 | − * lane configuration, and typically these values correspond to | |
| 2040 | − * the native resolution of the panel. With eDP 1.4 rate select | |
| 2041 | − * and DSC, this is decreasingly the case, and we need to be | |
| 2042 | − * able to select less than maximum link config. | |
| 2001 | + * advertizes being capable of. The panels are generally | |
| 2002 | + * designed to support only a single clock and lane | |
| 2003 | + * configuration, and typically these values correspond to the | |
| 2004 | + * native resolution of the panel. | |
| 2043 | 2005 | */ |
| 2044 | 2006 | limits.min_lane_count = limits.max_lane_count; |
| 2045 | 2007 | limits.min_clock = limits.max_clock; |
| @@ -2053,22 +2015,11 @@ intel_dp_compute_link_config(struct intel_encoder *encoder, · 7 unmodified lines | ||
| 2053 | 2015 | intel_dp->common_rates[limits.max_clock], |
| 2054 | 2016 | limits.max_bpp, adjusted_mode->crtc_clock); |
| 2055 | 2017 | |
| 2056 | − if (intel_dp_is_edp(intel_dp)) | |
| 2057 | − /* | |
| 2058 | − * Optimize for fast and narrow. eDP 1.3 section 3.3 and eDP 1.4 | |
| 2059 | − * section A.1: "It is recommended that the minimum number of | |
| 2060 | − * lanes be used, using the minimum link rate allowed for that | |
| 2061 | − * lane configuration." | |
| 2062 | − * | |
| 2063 | − * Note that we use the max clock and lane count for eDP 1.3 and | |
| 2064 | − * earlier, and fast vs. wide is irrelevant. | |
| 2065 | − */ | |
| 2066 | − ret = intel_dp_compute_link_config_fast(intel_dp, pipe_config, | |
| 2067 | − &limits); | |
| 2068 | − else | |
| 2069 | − /* Optimize for slow and wide. */ | |
| 2070 | − ret = intel_dp_compute_link_config_wide(intel_dp, pipe_config, | |
| 2071 | − &limits); | |
| 2018 | + /* | |
| 2019 | + * Optimize for slow and wide. This is the place to add alternative | |
| 2020 | + * optimization policy. | |
| 2021 | + */ | |
| 2022 | + ret = intel_dp_compute_link_config_wide(intel_dp, pipe_config, &limits); | |
| 2072 | 2023 | |
| 2073 | 2024 | /* enable compression if the mode doesn't fit available BW */ |
| 2074 | 2025 | DRM_DEBUG_KMS("Force DSC en = %d\n", intel_dp->force_dsc_en); |
| @@ -270,10 +270,12 @@ struct intel_encoder { · 269 unmodified lines | ||
| 270 | 270 | * be set correctly before calling this function. */ |
| 271 | 271 | void (*get_config)(struct intel_encoder *, |
| 272 | 272 | struct intel_crtc_state *pipe_config); |
| 273 | − /* Returns a mask of power domains that need to be referenced as part | |
| 274 | − * of the hardware state readout code. */ | |
| 275 | − u64 (*get_power_domains)(struct intel_encoder *encoder, | |
| 276 | − struct intel_crtc_state *crtc_state); | |
| 273 | + /* | |
| 274 | + * Acquires the power domains needed for an active encoder during | |
| 275 | + * hardware state readout. | |
| 276 | + */ | |
| 277 | + void (*get_power_domains)(struct intel_encoder *encoder, | |
| 278 | + struct intel_crtc_state *crtc_state); | |
| 277 | 279 | /* |
| 278 | 280 | * Called during system suspend after all pending requests for the |
| 279 | 281 | * encoder are flushed (for example for DP AUX transactions) and |
| @@ -256,6 +256,28 @@ static void band_gap_reset(struct drm_i915_private *dev_priv) · 255 unmodified lines | ||
| 256 | 256 | mutex_unlock(&dev_priv->sb_lock); |
| 257 | 257 | } |
| 258 | 258 | |
| 259 | +static int bdw_get_pipemisc_bpp(struct intel_crtc *crtc) | |
| 260 | +{ | |
| 261 | + struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); | |
| 262 | + u32 tmp; | |
| 263 | + | |
| 264 | + tmp = I915_READ(PIPEMISC(crtc->pipe)); | |
| 265 | + | |
| 266 | + switch (tmp & PIPEMISC_DITHER_BPC_MASK) { | |
| 267 | + case PIPEMISC_DITHER_6_BPC: | |
| 268 | + return 18; | |
| 269 | + case PIPEMISC_DITHER_8_BPC: | |
| 270 | + return 24; | |
| 271 | + case PIPEMISC_DITHER_10_BPC: | |
| 272 | + return 30; | |
| 273 | + case PIPEMISC_DITHER_12_BPC: | |
| 274 | + return 36; | |
| 275 | + default: | |
| 276 | + MISSING_CASE(tmp); | |
| 277 | + return 0; | |
| 278 | + } | |
| 279 | +} | |
| 280 | + | |
| 259 | 281 | static int intel_dsi_compute_config(struct intel_encoder *encoder, |
| 260 | 282 | struct intel_crtc_state *pipe_config, |
| 261 | 283 | struct drm_connector_state *conn_state) |
| @@ -1071,6 +1093,8 @@ static void bxt_dsi_get_pipe_config(struct intel_encoder *encoder, · 809 unmodified lines | ||
| 1071 | 1093 | bpp = mipi_dsi_pixel_format_to_bpp( |
| 1072 | 1094 | pixel_format_from_register_bits(fmt)); |
| 1073 | 1095 | |
| 1096 | + pipe_config->pipe_bpp = bdw_get_pipemisc_bpp(crtc); | |
| 1097 | + | |
| 1074 | 1098 | /* Enable Frame time stamo based scanline reporting */ |
| 1075 | 1099 | adjusted_mode->private_flags |= |
| 1076 | 1100 | I915_MODE_FLAG_GET_SCANLINE_FROM_TIMESTAMP; |
| @@ -662,13 +662,11 @@ static unsigned int mt8173_calculate_factor(int clock) · 661 unmodified lines | ||
| 662 | 662 | static unsigned int mt2701_calculate_factor(int clock) |
| 663 | 663 | { |
| 664 | 664 | if (clock <= 64000) |
| 665 | − return 16; | |
| 666 | − else if (clock <= 128000) | |
| 667 | − return 8; | |
| 668 | − else if (clock <= 256000) | |
| 669 | 665 | return 4; |
| 670 | − else | |
| 666 | + else if (clock <= 128000) | |
| 671 | 667 | return 2; |
| 668 | + else | |
| 669 | + return 1; | |
| 672 | 670 | } |
| 673 | 671 | |
| 674 | 672 | static const struct mtk_dpi_conf mt8173_conf = { |
| @@ -15,6 +15,7 @@ · 14 unmodified lines | ||
| 15 | 15 | #include <drm/drmP.h> |
| 16 | 16 | #include <drm/drm_atomic.h> |
| 17 | 17 | #include <drm/drm_atomic_helper.h> |
| 18 | +#include <drm/drm_fb_helper.h> | |
| 18 | 19 | #include <drm/drm_gem.h> |
| 19 | 20 | #include <drm/drm_gem_cma_helper.h> |
| 20 | 21 | #include <drm/drm_of.h> |
| @@ -341,6 +342,8 @@ static struct drm_driver mtk_drm_driver = { · 320 unmodified lines | ||
| 341 | 342 | .gem_prime_get_sg_table = mtk_gem_prime_get_sg_table, |
| 342 | 343 | .gem_prime_import_sg_table = mtk_gem_prime_import_sg_table, |
| 343 | 344 | .gem_prime_mmap = mtk_drm_gem_mmap_buf, |
| 345 | + .gem_prime_vmap = mtk_drm_gem_prime_vmap, | |
| 346 | + .gem_prime_vunmap = mtk_drm_gem_prime_vunmap, | |
| 344 | 347 | .fops = &mtk_drm_fops, |
| 345 | 348 | |
| 346 | 349 | .name = DRIVER_NAME, |
| @@ -376,6 +379,10 @@ static int mtk_drm_bind(struct device *dev) · 29 unmodified lines | ||
| 376 | 379 | if (ret < 0) |
| 377 | 380 | goto err_deinit; |
| 378 | 381 | |
| 382 | + ret = drm_fbdev_generic_setup(drm, 32); | |
| 383 | + if (ret) | |
| 384 | + DRM_ERROR("Failed to initialize fbdev: %d\n", ret); | |
| 385 | + | |
| 379 | 386 | return 0; |
| 380 | 387 | |
| 381 | 388 | err_deinit: |
| @@ -241,3 +241,49 @@ err_gem_free: · 240 unmodified lines | ||
| 241 | 241 | kfree(mtk_gem); |
| 242 | 242 | return ERR_PTR(ret); |
| 243 | 243 | } |
| 244 | + | |
| 245 | +void *mtk_drm_gem_prime_vmap(struct drm_gem_object *obj) | |
| 246 | +{ | |
| 247 | + struct mtk_drm_gem_obj *mtk_gem = to_mtk_gem_obj(obj); | |
| 248 | + struct sg_table *sgt; | |
| 249 | + struct sg_page_iter iter; | |
| 250 | + unsigned int npages; | |
| 251 | + unsigned int i = 0; | |
| 252 | + | |
| 253 | + if (mtk_gem->kvaddr) | |
| 254 | + return mtk_gem->kvaddr; | |
| 255 | + | |
| 256 | + sgt = mtk_gem_prime_get_sg_table(obj); | |
| 257 | + if (IS_ERR(sgt)) | |
| 258 | + return NULL; | |
| 259 | + | |
| 260 | + npages = obj->size >> PAGE_SHIFT; | |
| 261 | + mtk_gem->pages = kcalloc(npages, sizeof(*mtk_gem->pages), GFP_KERNEL); | |
| 262 | + if (!mtk_gem->pages) | |
| 263 | + goto out; | |
| 264 | + | |
| 265 | + for_each_sg_page(sgt->sgl, &iter, sgt->orig_nents, 0) { | |
| 266 | + mtk_gem->pages[i++] = sg_page_iter_page(&iter); | |
| 267 | + if (i > npages) | |
| 268 | + break; | |
| 269 | + } | |
| 270 | + mtk_gem->kvaddr = vmap(mtk_gem->pages, npages, VM_MAP, | |
| 271 | + pgprot_writecombine(PAGE_KERNEL)); | |
| 272 | + | |
| 273 | +out: | |
| 274 | + kfree((void *)sgt); | |
| 275 | + | |
| 276 | + return mtk_gem->kvaddr; | |
| 277 | +} | |
| 278 | + | |
| 279 | +void mtk_drm_gem_prime_vunmap(struct drm_gem_object *obj, void *vaddr) | |
| 280 | +{ | |
| 281 | + struct mtk_drm_gem_obj *mtk_gem = to_mtk_gem_obj(obj); | |
| 282 | + | |
| 283 | + if (!mtk_gem->pages) | |
| 284 | + return; | |
| 285 | + | |
| 286 | + vunmap(vaddr); | |
| 287 | + mtk_gem->kvaddr = 0; | |
| 288 | + kfree((void *)mtk_gem->pages); | |
| 289 | +} | |
| @@ -37,6 +37,7 @@ struct mtk_drm_gem_obj { · 36 unmodified lines | ||
| 37 | 37 | dma_addr_t dma_addr; |
| 38 | 38 | unsigned long dma_attrs; |
| 39 | 39 | struct sg_table *sg; |
| 40 | + struct page **pages; | |
| 40 | 41 | }; |
| 41 | 42 | |
| 42 | 43 | #define to_mtk_gem_obj(x) container_of(x, struct mtk_drm_gem_obj, base) |
| @@ -52,5 +53,7 @@ int mtk_drm_gem_mmap_buf(struct drm_gem_object *obj, · 9 unmodified lines | ||
| 52 | 53 | struct sg_table *mtk_gem_prime_get_sg_table(struct drm_gem_object *obj); |
| 53 | 54 | struct drm_gem_object *mtk_gem_prime_import_sg_table(struct drm_device *dev, |
| 54 | 55 | struct dma_buf_attachment *attach, struct sg_table *sg); |
| 56 | +void *mtk_drm_gem_prime_vmap(struct drm_gem_object *obj); | |
| 57 | +void mtk_drm_gem_prime_vunmap(struct drm_gem_object *obj, void *vaddr); | |
| 55 | 58 | |
| 56 | 59 | #endif |
| @@ -1480,7 +1480,6 @@ static int mtk_hdmi_dt_parse_pdata(struct mtk_hdmi *hdmi, · 1479 unmodified lines | ||
| 1480 | 1480 | if (IS_ERR(regmap)) |
| 1481 | 1481 | ret = PTR_ERR(regmap); |
| 1482 | 1482 | if (ret) { |
| 1483 | − ret = PTR_ERR(regmap); | |
| 1484 | 1483 | dev_err(dev, |
| 1485 | 1484 | "Failed to get system configuration registers: %d\n", |
| 1486 | 1485 | ret); |
| @@ -1516,6 +1515,7 @@ static int mtk_hdmi_dt_parse_pdata(struct mtk_hdmi *hdmi, · 29 unmodified lines | ||
| 1516 | 1515 | of_node_put(remote); |
| 1517 | 1516 | |
| 1518 | 1517 | hdmi->ddc_adpt = of_find_i2c_adapter_by_node(i2c_np); |
| 1518 | + of_node_put(i2c_np); | |
| 1519 | 1519 | if (!hdmi->ddc_adpt) { |
| 1520 | 1520 | dev_err(dev, "Failed to get ddc i2c adapter by node\n"); |
| 1521 | 1521 | return -EINVAL; |
| @@ -15,28 +15,6 @@ static const struct phy_ops mtk_hdmi_phy_dev_ops = { · 14 unmodified lines | ||
| 15 | 15 | .owner = THIS_MODULE, |
| 16 | 16 | }; |
| 17 | 17 | |
| 18 | −long mtk_hdmi_pll_round_rate(struct clk_hw *hw, unsigned long rate, | |
| 19 | − unsigned long *parent_rate) | |
| 20 | −{ | |
| 21 | − struct mtk_hdmi_phy *hdmi_phy = to_mtk_hdmi_phy(hw); | |
| 22 | − | |
| 23 | − hdmi_phy->pll_rate = rate; | |
| 24 | − if (rate <= 74250000) | |
| 25 | − *parent_rate = rate; | |
| 26 | − else | |
| 27 | − *parent_rate = rate / 2; | |
| 28 | − | |
| 29 | − return rate; | |
| 30 | −} | |
| 31 | − | |
| 32 | −unsigned long mtk_hdmi_pll_recalc_rate(struct clk_hw *hw, | |
| 33 | − unsigned long parent_rate) | |
| 34 | −{ | |
| 35 | − struct mtk_hdmi_phy *hdmi_phy = to_mtk_hdmi_phy(hw); | |
| 36 | − | |
| 37 | − return hdmi_phy->pll_rate; | |
| 38 | −} | |
| 39 | − | |
| 40 | 18 | void mtk_hdmi_phy_clear_bits(struct mtk_hdmi_phy *hdmi_phy, u32 offset, |
| 41 | 19 | u32 bits) |
| 42 | 20 | { |
| @@ -110,13 +88,11 @@ mtk_hdmi_phy_dev_get_ops(const struct mtk_hdmi_phy *hdmi_phy) · 67 unmodified lines | ||
| 110 | 88 | return NULL; |
| 111 | 89 | } |
| 112 | 90 | |
| 113 | −static void mtk_hdmi_phy_clk_get_ops(struct mtk_hdmi_phy *hdmi_phy, | |
| 114 | − const struct clk_ops **ops) | |
| 91 | +static void mtk_hdmi_phy_clk_get_data(struct mtk_hdmi_phy *hdmi_phy, | |
| 92 | + struct clk_init_data *clk_init) | |
| 115 | 93 | { |
| 116 | − if (hdmi_phy && hdmi_phy->conf && hdmi_phy->conf->hdmi_phy_clk_ops) | |
| 117 | − *ops = hdmi_phy->conf->hdmi_phy_clk_ops; | |
| 118 | − else | |
| 119 | − dev_err(hdmi_phy->dev, "Failed to get clk ops of phy\n"); | |
| 94 | + clk_init->flags = hdmi_phy->conf->flags; | |
| 95 | + clk_init->ops = hdmi_phy->conf->hdmi_phy_clk_ops; | |
| 120 | 96 | } |
| 121 | 97 | |
| 122 | 98 | static int mtk_hdmi_phy_probe(struct platform_device *pdev) |
| @@ -129,7 +105,6 @@ static int mtk_hdmi_phy_probe(struct platform_device *pdev) · 6 unmodified lines | ||
| 129 | 105 | struct clk_init_data clk_init = { |
| 130 | 106 | .num_parents = 1, |
| 131 | 107 | .parent_names = (const char * const *)&ref_clk_name, |
| 132 | − .flags = CLK_SET_RATE_PARENT | CLK_SET_RATE_GATE, | |
| 133 | 108 | }; |
| 134 | 109 | |
| 135 | 110 | struct phy *phy; |
| @@ -167,7 +142,7 @@ static int mtk_hdmi_phy_probe(struct platform_device *pdev) · 31 unmodified lines | ||
| 167 | 142 | hdmi_phy->dev = dev; |
| 168 | 143 | hdmi_phy->conf = |
| 169 | 144 | (struct mtk_hdmi_phy_conf *)of_device_get_match_data(dev); |
| 170 | − mtk_hdmi_phy_clk_get_ops(hdmi_phy, &clk_init.ops); | |
| 145 | + mtk_hdmi_phy_clk_get_data(hdmi_phy, &clk_init); | |
| 171 | 146 | hdmi_phy->pll_hw.init = &clk_init; |
| 172 | 147 | hdmi_phy->pll = devm_clk_register(dev, &hdmi_phy->pll_hw); |
| 173 | 148 | if (IS_ERR(hdmi_phy->pll)) { |
| @@ -21,6 +21,7 @@ struct mtk_hdmi_phy; · 20 unmodified lines | ||
| 21 | 21 | |
| 22 | 22 | struct mtk_hdmi_phy_conf { |
| 23 | 23 | bool tz_disabled; |
| 24 | + unsigned long flags; | |
| 24 | 25 | const struct clk_ops *hdmi_phy_clk_ops; |
| 25 | 26 | void (*hdmi_phy_enable_tmds)(struct mtk_hdmi_phy *hdmi_phy); |
| 26 | 27 | void (*hdmi_phy_disable_tmds)(struct mtk_hdmi_phy *hdmi_phy); |
| @@ -48,10 +49,6 @@ void mtk_hdmi_phy_set_bits(struct mtk_hdmi_phy *hdmi_phy, u32 offset, · 21 unmodified lines | ||
| 48 | 49 | void mtk_hdmi_phy_mask(struct mtk_hdmi_phy *hdmi_phy, u32 offset, |
| 49 | 50 | u32 val, u32 mask); |
| 50 | 51 | struct mtk_hdmi_phy *to_mtk_hdmi_phy(struct clk_hw *hw); |
| 51 | −long mtk_hdmi_pll_round_rate(struct clk_hw *hw, unsigned long rate, | |
| 52 | − unsigned long *parent_rate); | |
| 53 | −unsigned long mtk_hdmi_pll_recalc_rate(struct clk_hw *hw, | |
| 54 | − unsigned long parent_rate); | |
| 55 | 52 | |
| 56 | 53 | extern struct platform_driver mtk_hdmi_phy_driver; |
| 57 | 54 | extern struct mtk_hdmi_phy_conf mtk_hdmi_phy_8173_conf; |
| @@ -79,7 +79,6 @@ static int mtk_hdmi_pll_prepare(struct clk_hw *hw) · 78 unmodified lines | ||
| 79 | 79 | mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_SLDO_MASK); |
| 80 | 80 | usleep_range(80, 100); |
| 81 | 81 | mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON2, RG_HDMITX_MBIAS_LPF_EN); |
| 82 | − mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON2, RG_HDMITX_EN_TX_POSDIV); | |
| 83 | 82 | mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_SER_MASK); |
| 84 | 83 | mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_PRED_MASK); |
| 85 | 84 | mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_DRV_MASK); |
| @@ -94,7 +93,6 @@ static void mtk_hdmi_pll_unprepare(struct clk_hw *hw) · 8 unmodified lines | ||
| 94 | 93 | mtk_hdmi_phy_clear_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_DRV_MASK); |
| 95 | 94 | mtk_hdmi_phy_clear_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_PRED_MASK); |
| 96 | 95 | mtk_hdmi_phy_clear_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_SER_MASK); |
| 97 | − mtk_hdmi_phy_clear_bits(hdmi_phy, HDMI_CON2, RG_HDMITX_EN_TX_POSDIV); | |
| 98 | 96 | mtk_hdmi_phy_clear_bits(hdmi_phy, HDMI_CON2, RG_HDMITX_MBIAS_LPF_EN); |
| 99 | 97 | usleep_range(80, 100); |
| 100 | 98 | mtk_hdmi_phy_clear_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_SLDO_MASK); |
| @@ -108,6 +106,12 @@ static void mtk_hdmi_pll_unprepare(struct clk_hw *hw) · 7 unmodified lines | ||
| 108 | 106 | usleep_range(80, 100); |
| 109 | 107 | } |
| 110 | 108 | |
| 109 | +static long mtk_hdmi_pll_round_rate(struct clk_hw *hw, unsigned long rate, | |
| 110 | + unsigned long *parent_rate) | |
| 111 | +{ | |
| 112 | + return rate; | |
| 113 | +} | |
| 114 | + | |
| 111 | 115 | static int mtk_hdmi_pll_set_rate(struct clk_hw *hw, unsigned long rate, |
| 112 | 116 | unsigned long parent_rate) |
| 113 | 117 | { |
| @@ -116,13 +120,14 @@ static int mtk_hdmi_pll_set_rate(struct clk_hw *hw, unsigned long rate, · 2 unmodified lines | ||
| 116 | 120 | |
| 117 | 121 | if (rate <= 64000000) |
| 118 | 122 | pos_div = 3; |
| 119 | − else if (rate <= 12800000) | |
| 120 | − pos_div = 1; | |
| 123 | + else if (rate <= 128000000) | |
| 124 | + pos_div = 2; | |
| 121 | 125 | else |
| 122 | 126 | pos_div = 1; |
| 123 | 127 | |
| 124 | 128 | mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON6, RG_HTPLL_PREDIV_MASK); |
| 125 | 129 | mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON6, RG_HTPLL_POSDIV_MASK); |
| 130 | + mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON2, RG_HDMITX_EN_TX_POSDIV); | |
| 126 | 131 | mtk_hdmi_phy_mask(hdmi_phy, HDMI_CON6, (0x1 << RG_HTPLL_IC), |
| 127 | 132 | RG_HTPLL_IC_MASK); |
| 128 | 133 | mtk_hdmi_phy_mask(hdmi_phy, HDMI_CON6, (0x1 << RG_HTPLL_IR), |
| @@ -154,6 +159,39 @@ static int mtk_hdmi_pll_set_rate(struct clk_hw *hw, unsigned long rate, · 25 unmodified lines | ||
| 154 | 159 | return 0; |
| 155 | 160 | } |
| 156 | 161 | |
| 162 | +static unsigned long mtk_hdmi_pll_recalc_rate(struct clk_hw *hw, | |
| 163 | + unsigned long parent_rate) | |
| 164 | +{ | |
| 165 | + struct mtk_hdmi_phy *hdmi_phy = to_mtk_hdmi_phy(hw); | |
| 166 | + unsigned long out_rate, val; | |
| 167 | + | |
| 168 | + val = (readl(hdmi_phy->regs + HDMI_CON6) | |
| 169 | + & RG_HTPLL_PREDIV_MASK) >> RG_HTPLL_PREDIV; | |
| 170 | + switch (val) { | |
| 171 | + case 0x00: | |
| 172 | + out_rate = parent_rate; | |
| 173 | + break; | |
| 174 | + case 0x01: | |
| 175 | + out_rate = parent_rate / 2; | |
| 176 | + break; | |
| 177 | + default: | |
| 178 | + out_rate = parent_rate / 4; | |
| 179 | + break; | |
| 180 | + } | |
| 181 | + | |
| 182 | + val = (readl(hdmi_phy->regs + HDMI_CON6) | |
| 183 | + & RG_HTPLL_FBKDIV_MASK) >> RG_HTPLL_FBKDIV; | |
| 184 | + out_rate *= (val + 1) * 2; | |
| 185 | + val = (readl(hdmi_phy->regs + HDMI_CON2) | |
| 186 | + & RG_HDMITX_TX_POSDIV_MASK); | |
| 187 | + out_rate >>= (val >> RG_HDMITX_TX_POSDIV); | |
| 188 | + | |
| 189 | + if (readl(hdmi_phy->regs + HDMI_CON2) & RG_HDMITX_EN_TX_POSDIV) | |
| 190 | + out_rate /= 5; | |
| 191 | + | |
| 192 | + return out_rate; | |
| 193 | +} | |
| 194 | + | |
| 157 | 195 | static const struct clk_ops mtk_hdmi_phy_pll_ops = { |
| 158 | 196 | .prepare = mtk_hdmi_pll_prepare, |
| 159 | 197 | .unprepare = mtk_hdmi_pll_unprepare, |
| @@ -174,7 +212,6 @@ static void mtk_hdmi_phy_enable_tmds(struct mtk_hdmi_phy *hdmi_phy) · 14 unmodified lines | ||
| 174 | 212 | mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_SLDO_MASK); |
| 175 | 213 | usleep_range(80, 100); |
| 176 | 214 | mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON2, RG_HDMITX_MBIAS_LPF_EN); |
| 177 | − mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON2, RG_HDMITX_EN_TX_POSDIV); | |
| 178 | 215 | mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_SER_MASK); |
| 179 | 216 | mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_PRED_MASK); |
| 180 | 217 | mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_DRV_MASK); |
| @@ -186,7 +223,6 @@ static void mtk_hdmi_phy_disable_tmds(struct mtk_hdmi_phy *hdmi_phy) · 5 unmodified lines | ||
| 186 | 223 | mtk_hdmi_phy_clear_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_DRV_MASK); |
| 187 | 224 | mtk_hdmi_phy_clear_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_PRED_MASK); |
| 188 | 225 | mtk_hdmi_phy_clear_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_SER_MASK); |
| 189 | − mtk_hdmi_phy_clear_bits(hdmi_phy, HDMI_CON2, RG_HDMITX_EN_TX_POSDIV); | |
| 190 | 226 | mtk_hdmi_phy_clear_bits(hdmi_phy, HDMI_CON2, RG_HDMITX_MBIAS_LPF_EN); |
| 191 | 227 | usleep_range(80, 100); |
| 192 | 228 | mtk_hdmi_phy_clear_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_SLDO_MASK); |
| @@ -202,6 +238,7 @@ static void mtk_hdmi_phy_disable_tmds(struct mtk_hdmi_phy *hdmi_phy) · 9 unmodified lines | ||
| 202 | 238 | |
| 203 | 239 | struct mtk_hdmi_phy_conf mtk_hdmi_phy_2701_conf = { |
| 204 | 240 | .tz_disabled = true, |
| 241 | + .flags = CLK_SET_RATE_GATE, | |
| 205 | 242 | .hdmi_phy_clk_ops = &mtk_hdmi_phy_pll_ops, |
| 206 | 243 | .hdmi_phy_enable_tmds = mtk_hdmi_phy_enable_tmds, |
| 207 | 244 | .hdmi_phy_disable_tmds = mtk_hdmi_phy_disable_tmds, |
| @@ -199,6 +199,20 @@ static void mtk_hdmi_pll_unprepare(struct clk_hw *hw) · 198 unmodified lines | ||
| 199 | 199 | usleep_range(100, 150); |
| 200 | 200 | } |
| 201 | 201 | |
| 202 | +static long mtk_hdmi_pll_round_rate(struct clk_hw *hw, unsigned long rate, | |
| 203 | + unsigned long *parent_rate) | |
| 204 | +{ | |
| 205 | + struct mtk_hdmi_phy *hdmi_phy = to_mtk_hdmi_phy(hw); | |
| 206 | + | |
| 207 | + hdmi_phy->pll_rate = rate; | |
| 208 | + if (rate <= 74250000) | |
| 209 | + *parent_rate = rate; | |
| 210 | + else | |
| 211 | + *parent_rate = rate / 2; | |
| 212 | + | |
| 213 | + return rate; | |
| 214 | +} | |
| 215 | + | |
| 202 | 216 | static int mtk_hdmi_pll_set_rate(struct clk_hw *hw, unsigned long rate, |
| 203 | 217 | unsigned long parent_rate) |
| 204 | 218 | { |
| @@ -285,6 +299,14 @@ static int mtk_hdmi_pll_set_rate(struct clk_hw *hw, unsigned long rate, · 80 unmodified lines | ||
| 285 | 299 | return 0; |
| 286 | 300 | } |
| 287 | 301 | |
| 302 | +static unsigned long mtk_hdmi_pll_recalc_rate(struct clk_hw *hw, | |
| 303 | + unsigned long parent_rate) | |
| 304 | +{ | |
| 305 | + struct mtk_hdmi_phy *hdmi_phy = to_mtk_hdmi_phy(hw); | |
| 306 | + | |
| 307 | + return hdmi_phy->pll_rate; | |
| 308 | +} | |
| 309 | + | |
| 288 | 310 | static const struct clk_ops mtk_hdmi_phy_pll_ops = { |
| 289 | 311 | .prepare = mtk_hdmi_pll_prepare, |
| 290 | 312 | .unprepare = mtk_hdmi_pll_unprepare, |
| @@ -309,6 +331,7 @@ static void mtk_hdmi_phy_disable_tmds(struct mtk_hdmi_phy *hdmi_phy) · 18 unmodified lines | ||
| 309 | 331 | } |
| 310 | 332 | |
| 311 | 333 | struct mtk_hdmi_phy_conf mtk_hdmi_phy_8173_conf = { |
| 334 | + .flags = CLK_SET_RATE_PARENT | CLK_SET_RATE_GATE, | |
| 312 | 335 | .hdmi_phy_clk_ops = &mtk_hdmi_phy_pll_ops, |
| 313 | 336 | .hdmi_phy_enable_tmds = mtk_hdmi_phy_enable_tmds, |
| 314 | 337 | .hdmi_phy_disable_tmds = mtk_hdmi_phy_disable_tmds, |
| @@ -175,6 +175,7 @@ static int hdmi_cec_adap_enable(struct cec_adapter *adap, bool enable) · 174 unmodified lines | ||
| 175 | 175 | REG_FLD_MOD(core->base, HDMI_CORE_SYS_INTR_UNMASK4, 0, 3, 3); |
| 176 | 176 | hdmi_wp_clear_irqenable(core->wp, HDMI_IRQ_CORE); |
| 177 | 177 | hdmi_wp_set_irqstatus(core->wp, HDMI_IRQ_CORE); |
| 178 | + REG_FLD_MOD(core->wp->base, HDMI_WP_CLK, 0, 5, 0); | |
| 178 | 179 | hdmi4_core_disable(core); |
| 179 | 180 | return 0; |
| 180 | 181 | } |
| @@ -182,16 +183,24 @@ static int hdmi_cec_adap_enable(struct cec_adapter *adap, bool enable) · 1 unmodified line | ||
| 182 | 183 | if (err) |
| 183 | 184 | return err; |
| 184 | 185 | |
| 186 | + /* | |
| 187 | + * Initialize CEC clock divider: CEC needs 2MHz clock hence | |
| 188 | + * set the divider to 24 to get 48/24=2MHz clock | |
| 189 | + */ | |
| 190 | + REG_FLD_MOD(core->wp->base, HDMI_WP_CLK, 0x18, 5, 0); | |
| 191 | + | |
| 185 | 192 | /* Clear TX FIFO */ |
| 186 | 193 | if (!hdmi_cec_clear_tx_fifo(adap)) { |
| 187 | 194 | pr_err("cec-%s: could not clear TX FIFO\n", adap->name); |
| 188 | − return -EIO; | |
| 195 | + err = -EIO; | |
| 196 | + goto err_disable_clk; | |
| 189 | 197 | } |
| 190 | 198 | |
| 191 | 199 | /* Clear RX FIFO */ |
| 192 | 200 | if (!hdmi_cec_clear_rx_fifo(adap)) { |
| 193 | 201 | pr_err("cec-%s: could not clear RX FIFO\n", adap->name); |
| 194 | − return -EIO; | |
| 202 | + err = -EIO; | |
| 203 | + goto err_disable_clk; | |
| 195 | 204 | } |
| 196 | 205 | |
| 197 | 206 | /* Clear CEC interrupts */ |
| @@ -236,6 +245,12 @@ static int hdmi_cec_adap_enable(struct cec_adapter *adap, bool enable) · 38 unmodified lines | ||
| 236 | 245 | hdmi_write_reg(core->base, HDMI_CEC_INT_STATUS_1, temp); |
| 237 | 246 | } |
| 238 | 247 | return 0; |
| 248 | + | |
| 249 | +err_disable_clk: | |
| 250 | + REG_FLD_MOD(core->wp->base, HDMI_WP_CLK, 0, 5, 0); | |
| 251 | + hdmi4_core_disable(core); | |
| 252 | + | |
| 253 | + return err; | |
| 239 | 254 | } |
| 240 | 255 | |
| 241 | 256 | static int hdmi_cec_adap_log_addr(struct cec_adapter *adap, u8 log_addr) |
| @@ -333,11 +348,8 @@ int hdmi4_cec_init(struct platform_device *pdev, struct hdmi_core_data *core, · 91 unmodified lines | ||
| 333 | 348 | return ret; |
| 334 | 349 | core->wp = wp; |
| 335 | 350 | |
| 336 | − /* | |
| 337 | − * Initialize CEC clock divider: CEC needs 2MHz clock hence | |
| 338 | − * set the devider to 24 to get 48/24=2MHz clock | |
| 339 | − */ | |
| 340 | − REG_FLD_MOD(core->wp->base, HDMI_WP_CLK, 0x18, 5, 0); | |
| 351 | + /* Disable clock initially, hdmi_cec_adap_enable() manages it */ | |
| 352 | + REG_FLD_MOD(core->wp->base, HDMI_WP_CLK, 0, 5, 0); | |
| 341 | 353 | |
| 342 | 354 | ret = cec_register_adapter(core->adap, &pdev->dev); |
| 343 | 355 | if (ret < 0) { |
| @@ -708,7 +708,7 @@ int hdmi4_audio_config(struct hdmi_core_data *core, struct hdmi_wp_data *wp, · 707 unmodified lines | ||
| 708 | 708 | else |
| 709 | 709 | acore.i2s_cfg.justification = HDMI_AUDIO_JUSTIFY_RIGHT; |
| 710 | 710 | /* |
| 711 | − * The I2S input word length is twice the lenght given in the IEC-60958 | |
| 711 | + * The I2S input word length is twice the length given in the IEC-60958 | |
| 712 | 712 | * status word. If the word size is greater than |
| 713 | 713 | * 20 bits, increment by one. |
| 714 | 714 | */ |
| @@ -48,8 +48,13 @@ static enum drm_mode_status · 47 unmodified lines | ||
| 48 | 48 | sun8i_dw_hdmi_mode_valid_h6(struct drm_connector *connector, |
| 49 | 49 | const struct drm_display_mode *mode) |
| 50 | 50 | { |
| 51 | − /* This is max for HDMI 2.0b (4K@60Hz) */ | |
| 52 | − if (mode->clock > 594000) | |
| 51 | + /* | |
| 52 | + * Controller support maximum of 594 MHz, which correlates to | |
| 53 | + * 4K@60Hz 4:4:4 or RGB. However, for frequencies greater than | |
| 54 | + * 340 MHz scrambling has to be enabled. Because scrambling is | |
| 55 | + * not yet implemented, just limit to 340 MHz for now. | |
| 56 | + */ | |
| 57 | + if (mode->clock > 340000) | |
| 53 | 58 | return MODE_CLOCK_HIGH; |
| 54 | 59 | |
| 55 | 60 | return MODE_OK; |
| @@ -227,7 +227,7 @@ static int sun8i_tcon_top_bind(struct device *dev, struct device *master, · 226 unmodified lines | ||
| 227 | 227 | |
| 228 | 228 | err_unregister_gates: |
| 229 | 229 | for (i = 0; i < CLK_NUM; i++) |
| 230 | − if (clk_data->hws[i]) | |
| 230 | + if (!IS_ERR_OR_NULL(clk_data->hws[i])) | |
| 231 | 231 | clk_hw_unregister_gate(clk_data->hws[i]); |
| 232 | 232 | clk_disable_unprepare(tcon_top->bus); |
| 233 | 233 | err_assert_reset: |
| @@ -245,7 +245,8 @@ static void sun8i_tcon_top_unbind(struct device *dev, struct device *master, · 11 unmodified lines | ||
| 245 | 245 | |
| 246 | 246 | of_clk_del_provider(dev->of_node); |
| 247 | 247 | for (i = 0; i < CLK_NUM; i++) |
| 248 | − clk_hw_unregister_gate(clk_data->hws[i]); | |
| 248 | + if (clk_data->hws[i]) | |
| 249 | + clk_hw_unregister_gate(clk_data->hws[i]); | |
| 249 | 250 | |
| 250 | 251 | clk_disable_unprepare(tcon_top->bus); |
| 251 | 252 | reset_control_assert(tcon_top->rst); |
| @@ -52,6 +52,7 @@ static struct drm_driver driver = { · 51 unmodified lines | ||
| 52 | 52 | .driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_PRIME, |
| 53 | 53 | .load = udl_driver_load, |
| 54 | 54 | .unload = udl_driver_unload, |
| 55 | + .release = udl_driver_release, | |
| 55 | 56 | |
| 56 | 57 | /* gem hooks */ |
| 57 | 58 | .gem_free_object_unlocked = udl_gem_free_object, |
| @@ -104,6 +104,7 @@ void udl_urb_completion(struct urb *urb); · 103 unmodified lines | ||
| 104 | 104 | |
| 105 | 105 | int udl_driver_load(struct drm_device *dev, unsigned long flags); |
| 106 | 106 | void udl_driver_unload(struct drm_device *dev); |
| 107 | +void udl_driver_release(struct drm_device *dev); | |
| 107 | 108 | |
| 108 | 109 | int udl_fbdev_init(struct drm_device *dev); |
| 109 | 110 | void udl_fbdev_cleanup(struct drm_device *dev); |
| @@ -379,6 +379,12 @@ void udl_driver_unload(struct drm_device *dev) · 378 unmodified lines | ||
| 379 | 379 | udl_free_urb_list(dev); |
| 380 | 380 | |
| 381 | 381 | udl_fbdev_cleanup(dev); |
| 382 | − udl_modeset_cleanup(dev); | |
| 383 | 382 | kfree(udl); |
| 384 | 383 | } |
| 384 | + | |
| 385 | +void udl_driver_release(struct drm_device *dev) | |
| 386 | +{ | |
| 387 | + udl_modeset_cleanup(dev); | |
| 388 | + drm_dev_fini(dev); | |
| 389 | + kfree(dev); | |
| 390 | +} | |
| @@ -114,7 +114,7 @@ static inline void synchronize_syncpt_base(struct host1x_job *job) · 113 unmodified lines | ||
| 114 | 114 | |
| 115 | 115 | static void host1x_channel_set_streamid(struct host1x_channel *channel) |
| 116 | 116 | { |
| 117 | −#if HOST1X_HW >= 6 | |
| 117 | +#if IS_ENABLED(CONFIG_IOMMU_API) && HOST1X_HW >= 6 | |
| 118 | 118 | struct iommu_fwspec *spec = dev_iommu_fwspec_get(channel->dev->parent); |
| 119 | 119 | u32 sid = spec ? spec->ids[0] & 0xffff : 0x7f; |
| 120 | 120 | |
| @@ -13232,7 +13232,7 @@ static int set_up_context_variables(struct hfi1_devdata *dd) · 13231 unmodified lines | ||
| 13232 | 13232 | int total_contexts; |
| 13233 | 13233 | int ret; |
| 13234 | 13234 | unsigned ngroups; |
| 13235 | − int qos_rmt_count; | |
| 13235 | + int rmt_count; | |
| 13236 | 13236 | int user_rmt_reduced; |
| 13237 | 13237 | u32 n_usr_ctxts; |
| 13238 | 13238 | u32 send_contexts = chip_send_contexts(dd); |
| @@ -13294,10 +13294,20 @@ static int set_up_context_variables(struct hfi1_devdata *dd) · 55 unmodified lines | ||
| 13294 | 13294 | n_usr_ctxts = rcv_contexts - total_contexts; |
| 13295 | 13295 | } |
| 13296 | 13296 | |
| 13297 | − /* each user context requires an entry in the RMT */ | |
| 13298 | − qos_rmt_count = qos_rmt_entries(dd, NULL, NULL); | |
| 13299 | − if (qos_rmt_count + n_usr_ctxts > NUM_MAP_ENTRIES) { | |
| 13300 | − user_rmt_reduced = NUM_MAP_ENTRIES - qos_rmt_count; | |
| 13297 | + /* | |
| 13298 | + * The RMT entries are currently allocated as shown below: | |
| 13299 | + * 1. QOS (0 to 128 entries); | |
| 13300 | + * 2. FECN for PSM (num_user_contexts + num_vnic_contexts); | |
| 13301 | + * 3. VNIC (num_vnic_contexts). | |
| 13302 | + * It should be noted that PSM FECN oversubscribe num_vnic_contexts | |
| 13303 | + * entries of RMT because both VNIC and PSM could allocate any receive | |
| 13304 | + * context between dd->first_dyn_alloc_text and dd->num_rcv_contexts, | |
| 13305 | + * and PSM FECN must reserve an RMT entry for each possible PSM receive | |
| 13306 | + * context. | |
| 13307 | + */ | |
| 13308 | + rmt_count = qos_rmt_entries(dd, NULL, NULL) + (num_vnic_contexts * 2); | |
| 13309 | + if (rmt_count + n_usr_ctxts > NUM_MAP_ENTRIES) { | |
| 13310 | + user_rmt_reduced = NUM_MAP_ENTRIES - rmt_count; | |
| 13301 | 13311 | dd_dev_err(dd, |
| 13302 | 13312 | "RMT size is reducing the number of user receive contexts from %u to %d\n", |
| 13303 | 13313 | n_usr_ctxts, |
| @@ -14285,9 +14295,11 @@ static void init_user_fecn_handling(struct hfi1_devdata *dd, · 981 unmodified lines | ||
| 14285 | 14295 | u64 reg; |
| 14286 | 14296 | int i, idx, regoff, regidx; |
| 14287 | 14297 | u8 offset; |
| 14298 | + u32 total_cnt; | |
| 14288 | 14299 | |
| 14289 | 14300 | /* there needs to be enough room in the map table */ |
| 14290 | − if (rmt->used + dd->num_user_contexts >= NUM_MAP_ENTRIES) { | |
| 14301 | + total_cnt = dd->num_rcv_contexts - dd->first_dyn_alloc_ctxt; | |
| 14302 | + if (rmt->used + total_cnt >= NUM_MAP_ENTRIES) { | |
| 14291 | 14303 | dd_dev_err(dd, "User FECN handling disabled - too many user contexts allocated\n"); |
| 14292 | 14304 | return; |
| 14293 | 14305 | } |
| @@ -14341,7 +14353,7 @@ static void init_user_fecn_handling(struct hfi1_devdata *dd, · 47 unmodified lines | ||
| 14341 | 14353 | /* add rule 1 */ |
| 14342 | 14354 | add_rsm_rule(dd, RSM_INS_FECN, &rrd); |
| 14343 | 14355 | |
| 14344 | − rmt->used += dd->num_user_contexts; | |
| 14356 | + rmt->used += total_cnt; | |
| 14345 | 14357 | } |
| 14346 | 14358 | |
| 14347 | 14359 | /* Initialize RSM for VNIC */ |
| @@ -898,7 +898,9 @@ void notify_error_qp(struct rvt_qp *qp) · 897 unmodified lines | ||
| 898 | 898 | if (!list_empty(&priv->s_iowait.list) && |
| 899 | 899 | !(qp->s_flags & RVT_S_BUSY) && |
| 900 | 900 | !(priv->s_flags & RVT_S_BUSY)) { |
| 901 | − qp->s_flags &= ~RVT_S_ANY_WAIT_IO; | |
| 901 | + qp->s_flags &= ~HFI1_S_ANY_WAIT_IO; | |
| 902 | + iowait_clear_flag(&priv->s_iowait, IOWAIT_PENDING_IB); | |
| 903 | + iowait_clear_flag(&priv->s_iowait, IOWAIT_PENDING_TID); | |
| 902 | 904 | list_del_init(&priv->s_iowait.list); |
| 903 | 905 | priv->s_iowait.lock = NULL; |
| 904 | 906 | rvt_put_qp(qp); |
| @@ -3088,7 +3088,7 @@ send_last: · 3087 unmodified lines | ||
| 3088 | 3088 | update_ack_queue(qp, next); |
| 3089 | 3089 | } |
| 3090 | 3090 | e = &qp->s_ack_queue[qp->r_head_ack_queue]; |
| 3091 | − if (e->opcode == OP(RDMA_READ_REQUEST) && e->rdma_sge.mr) { | |
| 3091 | + if (e->rdma_sge.mr) { | |
| 3092 | 3092 | rvt_put_mr(e->rdma_sge.mr); |
| 3093 | 3093 | e->rdma_sge.mr = NULL; |
| 3094 | 3094 | } |
| @@ -3166,7 +3166,7 @@ send_last: · 71 unmodified lines | ||
| 3166 | 3166 | update_ack_queue(qp, next); |
| 3167 | 3167 | } |
| 3168 | 3168 | e = &qp->s_ack_queue[qp->r_head_ack_queue]; |
| 3169 | − if (e->opcode == OP(RDMA_READ_REQUEST) && e->rdma_sge.mr) { | |
| 3169 | + if (e->rdma_sge.mr) { | |
| 3170 | 3170 | rvt_put_mr(e->rdma_sge.mr); |
| 3171 | 3171 | e->rdma_sge.mr = NULL; |
| 3172 | 3172 | } |
| @@ -5017,24 +5017,14 @@ int hfi1_make_tid_rdma_pkt(struct rvt_qp *qp, struct hfi1_pkt_state *ps) · 5016 unmodified lines | ||
| 5017 | 5017 | make_tid_rdma_ack(qp, ohdr, ps)) |
| 5018 | 5018 | return 1; |
| 5019 | 5019 | |
| 5020 | − if (!(ib_rvt_state_ops[qp->state] & RVT_PROCESS_SEND_OK)) { | |
| 5021 | − if (!(ib_rvt_state_ops[qp->state] & RVT_FLUSH_SEND)) | |
| 5022 | − goto bail; | |
| 5023 | − /* We are in the error state, flush the work request. */ | |
| 5024 | − if (qp->s_last == READ_ONCE(qp->s_head)) | |
| 5025 | − goto bail; | |
| 5026 | − /* If DMAs are in progress, we can't flush immediately. */ | |
| 5027 | − if (iowait_sdma_pending(&priv->s_iowait)) { | |
| 5028 | − qp->s_flags |= RVT_S_WAIT_DMA; | |
| 5029 | − goto bail; | |
| 5030 | − } | |
| 5031 | − clear_ahg(qp); | |
| 5032 | − wqe = rvt_get_swqe_ptr(qp, qp->s_last); | |
| 5033 | − hfi1_trdma_send_complete(qp, wqe, qp->s_last != qp->s_acked ? | |
| 5034 | − IB_WC_SUCCESS : IB_WC_WR_FLUSH_ERR); | |
| 5035 | − /* will get called again */ | |
| 5036 | − goto done_free_tx; | |
| 5037 | − } | |
| 5020 | + /* | |
| 5021 | + * Bail out if we can't send data. | |
| 5022 | + * Be reminded that this check must been done after the call to | |
| 5023 | + * make_tid_rdma_ack() because the responding QP could be in | |
| 5024 | + * RTR state where it can send TID RDMA ACK, not TID RDMA WRITE DATA. | |
| 5025 | + */ | |
| 5026 | + if (!(ib_rvt_state_ops[qp->state] & RVT_PROCESS_SEND_OK)) | |
| 5027 | + goto bail; | |
| 5038 | 5028 | |
| 5039 | 5029 | if (priv->s_flags & RVT_S_WAIT_ACK) |
| 5040 | 5030 | goto bail; |
| @@ -5144,11 +5134,6 @@ int hfi1_make_tid_rdma_pkt(struct rvt_qp *qp, struct hfi1_pkt_state *ps) · 103 unmodified lines | ||
| 5144 | 5134 | hfi1_make_ruc_header(qp, ohdr, (opcode << 24), bth1, bth2, |
| 5145 | 5135 | middle, ps); |
| 5146 | 5136 | return 1; |
| 5147 | −done_free_tx: | |
| 5148 | − hfi1_put_txreq(ps->s_txreq); | |
| 5149 | − ps->s_txreq = NULL; | |
| 5150 | − return 1; | |
| 5151 | − | |
| 5152 | 5137 | bail: |
| 5153 | 5138 | hfi1_put_txreq(ps->s_txreq); |
| 5154 | 5139 | bail_no_tx: |
| @@ -792,6 +792,8 @@ void *hns_roce_table_find(struct hns_roce_dev *hr_dev, · 791 unmodified lines | ||
| 792 | 792 | idx_offset = (obj & (table->num_obj - 1)) % obj_per_chunk; |
| 793 | 793 | dma_offset = offset = idx_offset * table->obj_size; |
| 794 | 794 | } else { |
| 795 | + u32 seg_size = 64; /* 8 bytes per BA and 8 BA per segment */ | |
| 796 | + | |
| 795 | 797 | hns_roce_calc_hem_mhop(hr_dev, table, &mhop_obj, &mhop); |
| 796 | 798 | /* mtt mhop */ |
| 797 | 799 | i = mhop.l0_idx; |
| @@ -803,8 +805,8 @@ void *hns_roce_table_find(struct hns_roce_dev *hr_dev, · 5 unmodified lines | ||
| 803 | 805 | hem_idx = i; |
| 804 | 806 | |
| 805 | 807 | hem = table->hem[hem_idx]; |
| 806 | − dma_offset = offset = (obj & (table->num_obj - 1)) * | |
| 807 | − table->obj_size % mhop.bt_chunk_size; | |
| 808 | + dma_offset = offset = (obj & (table->num_obj - 1)) * seg_size % | |
| 809 | + mhop.bt_chunk_size; | |
| 808 | 810 | if (mhop.hop_num == 2) |
| 809 | 811 | dma_offset = offset = 0; |
| 810 | 812 | } |
| @@ -746,7 +746,6 @@ static int hns_roce_write_mtt_chunk(struct hns_roce_dev *hr_dev, · 745 unmodified lines | ||
| 746 | 746 | struct hns_roce_hem_table *table; |
| 747 | 747 | dma_addr_t dma_handle; |
| 748 | 748 | __le64 *mtts; |
| 749 | − u32 s = start_index * sizeof(u64); | |
| 750 | 749 | u32 bt_page_size; |
| 751 | 750 | u32 i; |
| 752 | 751 | |
| @@ -780,7 +779,8 @@ static int hns_roce_write_mtt_chunk(struct hns_roce_dev *hr_dev, · 27 unmodified lines | ||
| 780 | 779 | return -EINVAL; |
| 781 | 780 | |
| 782 | 781 | mtts = hns_roce_table_find(hr_dev, table, |
| 783 | − mtt->first_seg + s / hr_dev->caps.mtt_entry_sz, | |
| 782 | + mtt->first_seg + | |
| 783 | + start_index / HNS_ROCE_MTT_ENTRY_PER_SEG, | |
| 784 | 784 | &dma_handle); |
| 785 | 785 | if (!mtts) |
| 786 | 786 | return -ENOMEM; |
| @@ -274,9 +274,6 @@ void hns_roce_qp_free(struct hns_roce_dev *hr_dev, struct hns_roce_qp *hr_qp) · 273 unmodified lines | ||
| 274 | 274 | wait_for_completion(&hr_qp->free); |
| 275 | 275 | |
| 276 | 276 | if ((hr_qp->ibqp.qp_type) != IB_QPT_GSI) { |
| 277 | − if (hr_dev->caps.sccc_entry_sz) | |
| 278 | − hns_roce_table_put(hr_dev, &qp_table->sccc_table, | |
| 279 | − hr_qp->qpn); | |
| 280 | 277 | if (hr_dev->caps.trrl_entry_sz) |
| 281 | 278 | hns_roce_table_put(hr_dev, &qp_table->trrl_table, |
| 282 | 279 | hr_qp->qpn); |
| @@ -585,7 +585,7 @@ static int pagefault_mr(struct mlx5_ib_dev *dev, struct mlx5_ib_mr *mr, · 584 unmodified lines | ||
| 585 | 585 | struct ib_umem_odp *odp_mr = to_ib_umem_odp(mr->umem); |
| 586 | 586 | bool downgrade = flags & MLX5_PF_FLAGS_DOWNGRADE; |
| 587 | 587 | bool prefetch = flags & MLX5_PF_FLAGS_PREFETCH; |
| 588 | − u64 access_mask = ODP_READ_ALLOWED_BIT; | |
| 588 | + u64 access_mask; | |
| 589 | 589 | u64 start_idx, page_mask; |
| 590 | 590 | struct ib_umem_odp *odp; |
| 591 | 591 | size_t size; |
| @@ -607,6 +607,7 @@ next_mr: · 15 unmodified lines | ||
| 607 | 607 | page_shift = mr->umem->page_shift; |
| 608 | 608 | page_mask = ~(BIT(page_shift) - 1); |
| 609 | 609 | start_idx = (io_virt - (mr->mmkey.iova & page_mask)) >> page_shift; |
| 610 | + access_mask = ODP_READ_ALLOWED_BIT; | |
| 610 | 611 | |
| 611 | 612 | if (prefetch && !downgrade && !mr->umem->writable) { |
| 612 | 613 | /* prefetch with write-access must |
| @@ -1131,6 +1131,8 @@ static void pvrdma_pci_remove(struct pci_dev *pdev) · 1130 unmodified lines | ||
| 1131 | 1131 | pvrdma_page_dir_cleanup(dev, &dev->cq_pdir); |
| 1132 | 1132 | pvrdma_page_dir_cleanup(dev, &dev->async_pdir); |
| 1133 | 1133 | pvrdma_free_slots(dev); |
| 1134 | + dma_free_coherent(&pdev->dev, sizeof(*dev->dsr), dev->dsr, | |
| 1135 | + dev->dsrbase); | |
| 1134 | 1136 | |
| 1135 | 1137 | iounmap(dev->regs); |
| 1136 | 1138 | kfree(dev->sgid_tbl); |
| @@ -359,7 +359,7 @@ static void iommu_write_l2(struct amd_iommu *iommu, u8 address, u32 val) · 358 unmodified lines | ||
| 359 | 359 | static void iommu_set_exclusion_range(struct amd_iommu *iommu) |
| 360 | 360 | { |
| 361 | 361 | u64 start = iommu->exclusion_start & PAGE_MASK; |
| 362 | − u64 limit = (start + iommu->exclusion_length) & PAGE_MASK; | |
| 362 | + u64 limit = (start + iommu->exclusion_length - 1) & PAGE_MASK; | |
| 363 | 363 | u64 entry; |
| 364 | 364 | |
| 365 | 365 | if (!iommu->exclusion_start) |
| @@ -130,6 +130,7 @@ static int __init ls1x_intc_of_init(struct device_node *node, · 129 unmodified lines | ||
| 130 | 130 | NULL); |
| 131 | 131 | if (!priv->domain) { |
| 132 | 132 | pr_err("ls1x-irq: cannot add IRQ domain\n"); |
| 133 | + err = -ENOMEM; | |
| 133 | 134 | goto out_iounmap; |
| 134 | 135 | } |
| 135 | 136 | |
| @@ -710,10 +710,10 @@ base_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len) · 709 unmodified lines | ||
| 710 | 710 | struct sock *sk = sock->sk; |
| 711 | 711 | int err = 0; |
| 712 | 712 | |
| 713 | − if (!maddr || maddr->family != AF_ISDN) | |
| 713 | + if (addr_len < sizeof(struct sockaddr_mISDN)) | |
| 714 | 714 | return -EINVAL; |
| 715 | 715 | |
| 716 | − if (addr_len < sizeof(struct sockaddr_mISDN)) | |
| 716 | + if (!maddr || maddr->family != AF_ISDN) | |
| 717 | 717 | return -EINVAL; |
| 718 | 718 | |
| 719 | 719 | lock_sock(sk); |
| @@ -231,14 +231,14 @@ static void pblk_end_partial_read(struct nvm_rq *rqd) · 230 unmodified lines | ||
| 231 | 231 | struct pblk_sec_meta *meta; |
| 232 | 232 | struct bio *new_bio = rqd->bio; |
| 233 | 233 | struct bio *bio = pr_ctx->orig_bio; |
| 234 | − struct bio_vec src_bv, dst_bv; | |
| 235 | 234 | void *meta_list = rqd->meta_list; |
| 236 | − int bio_init_idx = pr_ctx->bio_init_idx; | |
| 237 | 235 | unsigned long *read_bitmap = pr_ctx->bitmap; |
| 236 | + struct bvec_iter orig_iter = BVEC_ITER_ALL_INIT; | |
| 237 | + struct bvec_iter new_iter = BVEC_ITER_ALL_INIT; | |
| 238 | 238 | int nr_secs = pr_ctx->orig_nr_secs; |
| 239 | 239 | int nr_holes = nr_secs - bitmap_weight(read_bitmap, nr_secs); |
| 240 | 240 | void *src_p, *dst_p; |
| 241 | − int hole, i; | |
| 241 | + int bit, i; | |
| 242 | 242 | |
| 243 | 243 | if (unlikely(nr_holes == 1)) { |
| 244 | 244 | struct ppa_addr ppa; |
| @@ -257,33 +257,39 @@ static void pblk_end_partial_read(struct nvm_rq *rqd) · 12 unmodified lines | ||
| 257 | 257 | |
| 258 | 258 | /* Fill the holes in the original bio */ |
| 259 | 259 | i = 0; |
| 260 | − hole = find_first_zero_bit(read_bitmap, nr_secs); | |
| 261 | − do { | |
| 262 | − struct pblk_line *line; | |
| 260 | + for (bit = 0; bit < nr_secs; bit++) { | |
| 261 | + if (!test_bit(bit, read_bitmap)) { | |
| 262 | + struct bio_vec dst_bv, src_bv; | |
| 263 | + struct pblk_line *line; | |
| 263 | 264 | |
| 264 | − line = pblk_ppa_to_line(pblk, rqd->ppa_list[i]); | |
| 265 | − kref_put(&line->ref, pblk_line_put); | |
| 265 | + line = pblk_ppa_to_line(pblk, rqd->ppa_list[i]); | |
| 266 | + kref_put(&line->ref, pblk_line_put); | |
| 266 | 267 | |
| 267 | − meta = pblk_get_meta(pblk, meta_list, hole); | |
| 268 | − meta->lba = cpu_to_le64(pr_ctx->lba_list_media[i]); | |
| 268 | + meta = pblk_get_meta(pblk, meta_list, bit); | |
| 269 | + meta->lba = cpu_to_le64(pr_ctx->lba_list_media[i]); | |
| 269 | 270 | |
| 270 | − src_bv = new_bio->bi_io_vec[i++]; | |
| 271 | − dst_bv = bio->bi_io_vec[bio_init_idx + hole]; | |
| 271 | + dst_bv = bio_iter_iovec(bio, orig_iter); | |
| 272 | + src_bv = bio_iter_iovec(new_bio, new_iter); | |
| 272 | 273 | |
| 273 | − src_p = kmap_atomic(src_bv.bv_page); | |
| 274 | − dst_p = kmap_atomic(dst_bv.bv_page); | |
| 274 | + src_p = kmap_atomic(src_bv.bv_page); | |
| 275 | + dst_p = kmap_atomic(dst_bv.bv_page); | |
| 275 | 276 | |
| 276 | − memcpy(dst_p + dst_bv.bv_offset, | |
| 277 | − src_p + src_bv.bv_offset, | |
| 278 | − PBLK_EXPOSED_PAGE_SIZE); | |
| 277 | + memcpy(dst_p + dst_bv.bv_offset, | |
| 278 | + src_p + src_bv.bv_offset, | |
| 279 | + PBLK_EXPOSED_PAGE_SIZE); | |
| 279 | 280 | |
| 280 | − kunmap_atomic(src_p); | |
| 281 | − kunmap_atomic(dst_p); | |
| 281 | + kunmap_atomic(src_p); | |
| 282 | + kunmap_atomic(dst_p); | |
| 282 | 283 | |
| 283 | − mempool_free(src_bv.bv_page, &pblk->page_bio_pool); | |
| 284 | + flush_dcache_page(dst_bv.bv_page); | |
| 285 | + mempool_free(src_bv.bv_page, &pblk->page_bio_pool); | |
| 284 | 286 | |
| 285 | − hole = find_next_zero_bit(read_bitmap, nr_secs, hole + 1); | |
| 286 | − } while (hole < nr_secs); | |
| 287 | + bio_advance_iter(new_bio, &new_iter, | |
| 288 | + PBLK_EXPOSED_PAGE_SIZE); | |
| 289 | + i++; | |
| 290 | + } | |
| 291 | + bio_advance_iter(bio, &orig_iter, PBLK_EXPOSED_PAGE_SIZE); | |
| 292 | + } | |
| 287 | 293 | |
| 288 | 294 | bio_put(new_bio); |
| 289 | 295 | kfree(pr_ctx); |
| @@ -48,7 +48,6 @@ struct alcor_sdmmc_host { · 47 unmodified lines | ||
| 48 | 48 | struct mmc_command *cmd; |
| 49 | 49 | struct mmc_data *data; |
| 50 | 50 | unsigned int dma_on:1; |
| 51 | − unsigned int early_data:1; | |
| 52 | 51 | |
| 53 | 52 | struct mutex cmd_mutex; |
| 54 | 53 | |
| @@ -144,8 +143,7 @@ static void alcor_data_set_dma(struct alcor_sdmmc_host *host) · 89 unmodified lines | ||
| 144 | 143 | host->sg_count--; |
| 145 | 144 | } |
| 146 | 145 | |
| 147 | −static void alcor_trigger_data_transfer(struct alcor_sdmmc_host *host, | |
| 148 | − bool early) | |
| 146 | +static void alcor_trigger_data_transfer(struct alcor_sdmmc_host *host) | |
| 149 | 147 | { |
| 150 | 148 | struct alcor_pci_priv *priv = host->alcor_pci; |
| 151 | 149 | struct mmc_data *data = host->data; |
| @@ -155,13 +153,6 @@ static void alcor_trigger_data_transfer(struct alcor_sdmmc_host *host, · 3 unmodified lines | ||
| 155 | 153 | ctrl |= AU6601_DATA_WRITE; |
| 156 | 154 | |
| 157 | 155 | if (data->host_cookie == COOKIE_MAPPED) { |
| 158 | − if (host->early_data) { | |
| 159 | − host->early_data = false; | |
| 160 | − return; | |
| 161 | − } | |
| 162 | − | |
| 163 | − host->early_data = early; | |
| 164 | − | |
| 165 | 156 | alcor_data_set_dma(host); |
| 166 | 157 | ctrl |= AU6601_DATA_DMA_MODE; |
| 167 | 158 | host->dma_on = 1; |
| @@ -231,6 +222,7 @@ static void alcor_prepare_sg_miter(struct alcor_sdmmc_host *host) · 63 unmodified lines | ||
| 231 | 222 | static void alcor_prepare_data(struct alcor_sdmmc_host *host, |
| 232 | 223 | struct mmc_command *cmd) |
| 233 | 224 | { |
| 225 | + struct alcor_pci_priv *priv = host->alcor_pci; | |
| 234 | 226 | struct mmc_data *data = cmd->data; |
| 235 | 227 | |
| 236 | 228 | if (!data) |
| @@ -248,7 +240,7 @@ static void alcor_prepare_data(struct alcor_sdmmc_host *host, · 11 unmodified lines | ||
| 248 | 240 | if (data->host_cookie != COOKIE_MAPPED) |
| 249 | 241 | alcor_prepare_sg_miter(host); |
| 250 | 242 | |
| 251 | − alcor_trigger_data_transfer(host, true); | |
| 243 | + alcor_write8(priv, 0, AU6601_DATA_XFER_CTRL); | |
| 252 | 244 | } |
| 253 | 245 | |
| 254 | 246 | static void alcor_send_cmd(struct alcor_sdmmc_host *host, |
| @@ -435,7 +427,7 @@ static int alcor_cmd_irq_done(struct alcor_sdmmc_host *host, u32 intmask) · 180 unmodified lines | ||
| 435 | 427 | if (!host->data) |
| 436 | 428 | return false; |
| 437 | 429 | |
| 438 | − alcor_trigger_data_transfer(host, false); | |
| 430 | + alcor_trigger_data_transfer(host); | |
| 439 | 431 | host->cmd = NULL; |
| 440 | 432 | return true; |
| 441 | 433 | } |
| @@ -456,7 +448,7 @@ static void alcor_cmd_irq_thread(struct alcor_sdmmc_host *host, u32 intmask) · 14 unmodified lines | ||
| 456 | 448 | if (!host->data) |
| 457 | 449 | alcor_request_complete(host, 1); |
| 458 | 450 | else |
| 459 | − alcor_trigger_data_transfer(host, false); | |
| 451 | + alcor_trigger_data_transfer(host); | |
| 460 | 452 | host->cmd = NULL; |
| 461 | 453 | } |
| 462 | 454 | |
| @@ -487,15 +479,9 @@ static int alcor_data_irq_done(struct alcor_sdmmc_host *host, u32 intmask) · 24 unmodified lines | ||
| 487 | 479 | break; |
| 488 | 480 | case AU6601_INT_READ_BUF_RDY: |
| 489 | 481 | alcor_trf_block_pio(host, true); |
| 490 | − if (!host->blocks) | |
| 491 | − break; | |
| 492 | − alcor_trigger_data_transfer(host, false); | |
| 493 | 482 | return 1; |
| 494 | 483 | case AU6601_INT_WRITE_BUF_RDY: |
| 495 | 484 | alcor_trf_block_pio(host, false); |
| 496 | − if (!host->blocks) | |
| 497 | − break; | |
| 498 | − alcor_trigger_data_transfer(host, false); | |
| 499 | 485 | return 1; |
| 500 | 486 | case AU6601_INT_DMA_END: |
| 501 | 487 | if (!host->sg_count) |
| @@ -508,8 +494,14 @@ static int alcor_data_irq_done(struct alcor_sdmmc_host *host, u32 intmask) · 6 unmodified lines | ||
| 508 | 494 | break; |
| 509 | 495 | } |
| 510 | 496 | |
| 511 | − if (intmask & AU6601_INT_DATA_END) | |
| 512 | − return 0; | |
| 497 | + if (intmask & AU6601_INT_DATA_END) { | |
| 498 | + if (!host->dma_on && host->blocks) { | |
| 499 | + alcor_trigger_data_transfer(host); | |
| 500 | + return 1; | |
| 501 | + } else { | |
| 502 | + return 0; | |
| 503 | + } | |
| 504 | + } | |
| 513 | 505 | |
| 514 | 506 | return 1; |
| 515 | 507 | } |
| @@ -797,6 +797,43 @@ void sdhci_omap_reset(struct sdhci_host *host, u8 mask) · 796 unmodified lines | ||
| 797 | 797 | sdhci_reset(host, mask); |
| 798 | 798 | } |
| 799 | 799 | |
| 800 | +#define CMD_ERR_MASK (SDHCI_INT_CRC | SDHCI_INT_END_BIT | SDHCI_INT_INDEX |\ | |
| 801 | + SDHCI_INT_TIMEOUT) | |
| 802 | +#define CMD_MASK (CMD_ERR_MASK | SDHCI_INT_RESPONSE) | |
| 803 | + | |
| 804 | +static u32 sdhci_omap_irq(struct sdhci_host *host, u32 intmask) | |
| 805 | +{ | |
| 806 | + struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); | |
| 807 | + struct sdhci_omap_host *omap_host = sdhci_pltfm_priv(pltfm_host); | |
| 808 | + | |
| 809 | + if (omap_host->is_tuning && host->cmd && !host->data_early && | |
| 810 | + (intmask & CMD_ERR_MASK)) { | |
| 811 | + | |
| 812 | + /* | |
| 813 | + * Since we are not resetting data lines during tuning | |
| 814 | + * operation, data error or data complete interrupts | |
| 815 | + * might still arrive. Mark this request as a failure | |
| 816 | + * but still wait for the data interrupt | |
| 817 | + */ | |
| 818 | + if (intmask & SDHCI_INT_TIMEOUT) | |
| 819 | + host->cmd->error = -ETIMEDOUT; | |
| 820 | + else | |
| 821 | + host->cmd->error = -EILSEQ; | |
| 822 | + | |
| 823 | + host->cmd = NULL; | |
| 824 | + | |
| 825 | + /* | |
| 826 | + * Sometimes command error interrupts and command complete | |
| 827 | + * interrupt will arrive together. Clear all command related | |
| 828 | + * interrupts here. | |
| 829 | + */ | |
| 830 | + sdhci_writel(host, intmask & CMD_MASK, SDHCI_INT_STATUS); | |
| 831 | + intmask &= ~CMD_MASK; | |
| 832 | + } | |
| 833 | + | |
| 834 | + return intmask; | |
| 835 | +} | |
| 836 | + | |
| 800 | 837 | static struct sdhci_ops sdhci_omap_ops = { |
| 801 | 838 | .set_clock = sdhci_omap_set_clock, |
| 802 | 839 | .set_power = sdhci_omap_set_power, |
| @@ -807,6 +844,7 @@ static struct sdhci_ops sdhci_omap_ops = { · 4 unmodified lines | ||
| 807 | 844 | .platform_send_init_74_clocks = sdhci_omap_init_74_clocks, |
| 808 | 845 | .reset = sdhci_omap_reset, |
| 809 | 846 | .set_uhs_signaling = sdhci_omap_set_uhs_signaling, |
| 847 | + .irq = sdhci_omap_irq, | |
| 810 | 848 | }; |
| 811 | 849 | |
| 812 | 850 | static int sdhci_omap_set_capabilities(struct sdhci_omap_host *omap_host) |
| @@ -3213,8 +3213,12 @@ static int bond_netdev_event(struct notifier_block *this, · 3212 unmodified lines | ||
| 3213 | 3213 | return NOTIFY_DONE; |
| 3214 | 3214 | |
| 3215 | 3215 | if (event_dev->flags & IFF_MASTER) { |
| 3216 | + int ret; | |
| 3217 | + | |
| 3216 | 3218 | netdev_dbg(event_dev, "IFF_MASTER\n"); |
| 3217 | − return bond_master_netdev_event(event, event_dev); | |
| 3219 | + ret = bond_master_netdev_event(event, event_dev); | |
| 3220 | + if (ret != NOTIFY_DONE) | |
| 3221 | + return ret; | |
| 3218 | 3222 | } |
| 3219 | 3223 | |
| 3220 | 3224 | if (event_dev->flags & IFF_SLAVE) { |
| @@ -957,7 +957,7 @@ int bnx2x_vfpf_update_vlan(struct bnx2x *bp, u16 vid, u8 vf_qid, bool add) · 956 unmodified lines | ||
| 957 | 957 | bnx2x_sample_bulletin(bp); |
| 958 | 958 | |
| 959 | 959 | if (bp->shadow_bulletin.content.valid_bitmap & 1 << VLAN_VALID) { |
| 960 | − BNX2X_ERR("Hypervisor will dicline the request, avoiding\n"); | |
| 960 | + BNX2X_ERR("Hypervisor will decline the request, avoiding\n"); | |
| 961 | 961 | rc = -EINVAL; |
| 962 | 962 | goto out; |
| 963 | 963 | } |
| @@ -32,6 +32,13 @@ · 31 unmodified lines | ||
| 32 | 32 | #define DRV_NAME "nicvf" |
| 33 | 33 | #define DRV_VERSION "1.0" |
| 34 | 34 | |
| 35 | +/* NOTE: Packets bigger than 1530 are split across multiple pages and XDP needs | |
| 36 | + * the buffer to be contiguous. Allow XDP to be set up only if we don't exceed | |
| 37 | + * this value, keeping headroom for the 14 byte Ethernet header and two | |
| 38 | + * VLAN tags (for QinQ) | |
| 39 | + */ | |
| 40 | +#define MAX_XDP_MTU (1530 - ETH_HLEN - VLAN_HLEN * 2) | |
| 41 | + | |
| 35 | 42 | /* Supported devices */ |
| 36 | 43 | static const struct pci_device_id nicvf_id_table[] = { |
| 37 | 44 | { PCI_DEVICE_SUB(PCI_VENDOR_ID_CAVIUM, |
| @@ -1582,6 +1589,15 @@ static int nicvf_change_mtu(struct net_device *netdev, int new_mtu) · 1544 unmodified lines | ||
| 1582 | 1589 | struct nicvf *nic = netdev_priv(netdev); |
| 1583 | 1590 | int orig_mtu = netdev->mtu; |
| 1584 | 1591 | |
| 1592 | + /* For now just support only the usual MTU sized frames, | |
| 1593 | + * plus some headroom for VLAN, QinQ. | |
| 1594 | + */ | |
| 1595 | + if (nic->xdp_prog && new_mtu > MAX_XDP_MTU) { | |
| 1596 | + netdev_warn(netdev, "Jumbo frames not yet supported with XDP, current MTU %d.\n", | |
| 1597 | + netdev->mtu); | |
| 1598 | + return -EINVAL; | |
| 1599 | + } | |
| 1600 | + | |
| 1585 | 1601 | netdev->mtu = new_mtu; |
| 1586 | 1602 | |
| 1587 | 1603 | if (!netif_running(netdev)) |
| @@ -1830,8 +1846,10 @@ static int nicvf_xdp_setup(struct nicvf *nic, struct bpf_prog *prog) · 242 unmodified lines | ||
| 1830 | 1846 | bool bpf_attached = false; |
| 1831 | 1847 | int ret = 0; |
| 1832 | 1848 | |
| 1833 | − /* For now just support only the usual MTU sized frames */ | |
| 1834 | − if (prog && (dev->mtu > 1500)) { | |
| 1849 | + /* For now just support only the usual MTU sized frames, | |
| 1850 | + * plus some headroom for VLAN, QinQ. | |
| 1851 | + */ | |
| 1852 | + if (prog && dev->mtu > MAX_XDP_MTU) { | |
| 1835 | 1853 | netdev_warn(dev, "Jumbo frames not yet supported with XDP, current MTU %d.\n", |
| 1836 | 1854 | dev->mtu); |
| 1837 | 1855 | return -EOPNOTSUPP; |
| @@ -1840,13 +1840,9 @@ static int fec_enet_clk_enable(struct net_device *ndev, bool enable) · 1839 unmodified lines | ||
| 1840 | 1840 | int ret; |
| 1841 | 1841 | |
| 1842 | 1842 | if (enable) { |
| 1843 | − ret = clk_prepare_enable(fep->clk_ahb); | |
| 1844 | − if (ret) | |
| 1845 | − return ret; | |
| 1846 | − | |
| 1847 | 1843 | ret = clk_prepare_enable(fep->clk_enet_out); |
| 1848 | 1844 | if (ret) |
| 1849 | − goto failed_clk_enet_out; | |
| 1845 | + return ret; | |
| 1850 | 1846 | |
| 1851 | 1847 | if (fep->clk_ptp) { |
| 1852 | 1848 | mutex_lock(&fep->ptp_clk_mutex); |
| @@ -1866,7 +1862,6 @@ static int fec_enet_clk_enable(struct net_device *ndev, bool enable) · 13 unmodified lines | ||
| 1866 | 1862 | |
| 1867 | 1863 | phy_reset_after_clk_enable(ndev->phydev); |
| 1868 | 1864 | } else { |
| 1869 | − clk_disable_unprepare(fep->clk_ahb); | |
| 1870 | 1865 | clk_disable_unprepare(fep->clk_enet_out); |
| 1871 | 1866 | if (fep->clk_ptp) { |
| 1872 | 1867 | mutex_lock(&fep->ptp_clk_mutex); |
| @@ -1885,8 +1880,6 @@ failed_clk_ref: · 12 unmodified lines | ||
| 1885 | 1880 | failed_clk_ptp: |
| 1886 | 1881 | if (fep->clk_enet_out) |
| 1887 | 1882 | clk_disable_unprepare(fep->clk_enet_out); |
| 1888 | −failed_clk_enet_out: | |
| 1889 | − clk_disable_unprepare(fep->clk_ahb); | |
| 1890 | 1883 | |
| 1891 | 1884 | return ret; |
| 1892 | 1885 | } |
| @@ -3470,6 +3463,9 @@ fec_probe(struct platform_device *pdev) · 1577 unmodified lines | ||
| 3470 | 3463 | ret = clk_prepare_enable(fep->clk_ipg); |
| 3471 | 3464 | if (ret) |
| 3472 | 3465 | goto failed_clk_ipg; |
| 3466 | + ret = clk_prepare_enable(fep->clk_ahb); | |
| 3467 | + if (ret) | |
| 3468 | + goto failed_clk_ahb; | |
| 3473 | 3469 | |
| 3474 | 3470 | fep->reg_phy = devm_regulator_get_optional(&pdev->dev, "phy"); |
| 3475 | 3471 | if (!IS_ERR(fep->reg_phy)) { |
| @@ -3563,6 +3559,9 @@ failed_reset: · 87 unmodified lines | ||
| 3563 | 3559 | pm_runtime_put(&pdev->dev); |
| 3564 | 3560 | pm_runtime_disable(&pdev->dev); |
| 3565 | 3561 | failed_regulator: |
| 3562 | + clk_disable_unprepare(fep->clk_ahb); | |
| 3563 | +failed_clk_ahb: | |
| 3564 | + clk_disable_unprepare(fep->clk_ipg); | |
| 3566 | 3565 | failed_clk_ipg: |
| 3567 | 3566 | fec_enet_clk_enable(ndev, false); |
| 3568 | 3567 | failed_clk: |
| @@ -3686,6 +3685,7 @@ static int __maybe_unused fec_runtime_suspend(struct device *dev) · 117 unmodified lines | ||
| 3686 | 3685 | struct net_device *ndev = dev_get_drvdata(dev); |
| 3687 | 3686 | struct fec_enet_private *fep = netdev_priv(ndev); |
| 3688 | 3687 | |
| 3688 | + clk_disable_unprepare(fep->clk_ahb); | |
| 3689 | 3689 | clk_disable_unprepare(fep->clk_ipg); |
| 3690 | 3690 | |
| 3691 | 3691 | return 0; |
| @@ -3695,8 +3695,20 @@ static int __maybe_unused fec_runtime_resume(struct device *dev) · 3 unmodified lines | ||
| 3695 | 3695 | { |
| 3696 | 3696 | struct net_device *ndev = dev_get_drvdata(dev); |
| 3697 | 3697 | struct fec_enet_private *fep = netdev_priv(ndev); |
| 3698 | + int ret; | |
| 3698 | 3699 | |
| 3699 | − return clk_prepare_enable(fep->clk_ipg); | |
| 3700 | + ret = clk_prepare_enable(fep->clk_ahb); | |
| 3701 | + if (ret) | |
| 3702 | + return ret; | |
| 3703 | + ret = clk_prepare_enable(fep->clk_ipg); | |
| 3704 | + if (ret) | |
| 3705 | + goto failed_clk_ipg; | |
| 3706 | + | |
| 3707 | + return 0; | |
| 3708 | + | |
| 3709 | +failed_clk_ipg: | |
| 3710 | + clk_disable_unprepare(fep->clk_ahb); | |
| 3711 | + return ret; | |
| 3700 | 3712 | } |
| 3701 | 3713 | |
| 3702 | 3714 | static const struct dev_pm_ops fec_pm_ops = { |
| @@ -3758,6 +3758,7 @@ static void handle_query_ip_offload_rsp(struct ibmvnic_adapter *adapter) · 3757 unmodified lines | ||
| 3758 | 3758 | { |
| 3759 | 3759 | struct device *dev = &adapter->vdev->dev; |
| 3760 | 3760 | struct ibmvnic_query_ip_offload_buffer *buf = &adapter->ip_offload_buf; |
| 3761 | + netdev_features_t old_hw_features = 0; | |
| 3761 | 3762 | union ibmvnic_crq crq; |
| 3762 | 3763 | int i; |
| 3763 | 3764 | |
| @@ -3833,24 +3834,41 @@ static void handle_query_ip_offload_rsp(struct ibmvnic_adapter *adapter) · 69 unmodified lines | ||
| 3833 | 3834 | adapter->ip_offload_ctrl.large_rx_ipv4 = 0; |
| 3834 | 3835 | adapter->ip_offload_ctrl.large_rx_ipv6 = 0; |
| 3835 | 3836 | |
| 3836 | − adapter->netdev->features = NETIF_F_SG | NETIF_F_GSO; | |
| 3837 | + if (adapter->state != VNIC_PROBING) { | |
| 3838 | + old_hw_features = adapter->netdev->hw_features; | |
| 3839 | + adapter->netdev->hw_features = 0; | |
| 3840 | + } | |
| 3841 | + | |
| 3842 | + adapter->netdev->hw_features = NETIF_F_SG | NETIF_F_GSO | NETIF_F_GRO; | |
| 3837 | 3843 | |
| 3838 | 3844 | if (buf->tcp_ipv4_chksum || buf->udp_ipv4_chksum) |
| 3839 | − adapter->netdev->features |= NETIF_F_IP_CSUM; | |
| 3845 | + adapter->netdev->hw_features |= NETIF_F_IP_CSUM; | |
| 3840 | 3846 | |
| 3841 | 3847 | if (buf->tcp_ipv6_chksum || buf->udp_ipv6_chksum) |
| 3842 | − adapter->netdev->features |= NETIF_F_IPV6_CSUM; | |
| 3848 | + adapter->netdev->hw_features |= NETIF_F_IPV6_CSUM; | |
| 3843 | 3849 | |
| 3844 | 3850 | if ((adapter->netdev->features & |
| 3845 | 3851 | (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM))) |
| 3846 | − adapter->netdev->features |= NETIF_F_RXCSUM; | |
| 3852 | + adapter->netdev->hw_features |= NETIF_F_RXCSUM; | |
| 3847 | 3853 | |
| 3848 | 3854 | if (buf->large_tx_ipv4) |
| 3849 | − adapter->netdev->features |= NETIF_F_TSO; | |
| 3855 | + adapter->netdev->hw_features |= NETIF_F_TSO; | |
| 3850 | 3856 | if (buf->large_tx_ipv6) |
| 3851 | − adapter->netdev->features |= NETIF_F_TSO6; | |
| 3857 | + adapter->netdev->hw_features |= NETIF_F_TSO6; | |
| 3852 | 3858 | |
| 3853 | − adapter->netdev->hw_features |= adapter->netdev->features; | |
| 3859 | + if (adapter->state == VNIC_PROBING) { | |
| 3860 | + adapter->netdev->features |= adapter->netdev->hw_features; | |
| 3861 | + } else if (old_hw_features != adapter->netdev->hw_features) { | |
| 3862 | + netdev_features_t tmp = 0; | |
| 3863 | + | |
| 3864 | + /* disable features no longer supported */ | |
| 3865 | + adapter->netdev->features &= adapter->netdev->hw_features; | |
| 3866 | + /* turn on features now supported if previously enabled */ | |
| 3867 | + tmp = (old_hw_features ^ adapter->netdev->hw_features) & | |
| 3868 | + adapter->netdev->hw_features; | |
| 3869 | + adapter->netdev->features |= | |
| 3870 | + tmp & adapter->netdev->wanted_features; | |
| 3871 | + } | |
| 3854 | 3872 | |
| 3855 | 3873 | memset(&crq, 0, sizeof(crq)); |
| 3856 | 3874 | crq.control_ip_offload.first = IBMVNIC_CRQ_CMD; |
| @@ -856,6 +856,7 @@ void mlx5e_close_channels(struct mlx5e_channels *chs); · 855 unmodified lines | ||
| 856 | 856 | * switching channels |
| 857 | 857 | */ |
| 858 | 858 | typedef int (*mlx5e_fp_hw_modify)(struct mlx5e_priv *priv); |
| 859 | +int mlx5e_safe_reopen_channels(struct mlx5e_priv *priv); | |
| 859 | 860 | int mlx5e_safe_switch_channels(struct mlx5e_priv *priv, |
| 860 | 861 | struct mlx5e_channels *new_chs, |
| 861 | 862 | mlx5e_fp_hw_modify hw_modify); |
| @@ -186,12 +186,17 @@ static int mlx5e_tx_reporter_recover_from_ctx(struct mlx5e_tx_err_ctx *err_ctx) · 185 unmodified lines | ||
| 186 | 186 | |
| 187 | 187 | static int mlx5e_tx_reporter_recover_all(struct mlx5e_priv *priv) |
| 188 | 188 | { |
| 189 | − int err; | |
| 189 | + int err = 0; | |
| 190 | 190 | |
| 191 | 191 | rtnl_lock(); |
| 192 | 192 | mutex_lock(&priv->state_lock); |
| 193 | − mlx5e_close_locked(priv->netdev); | |
| 194 | − err = mlx5e_open_locked(priv->netdev); | |
| 193 | + | |
| 194 | + if (!test_bit(MLX5E_STATE_OPENED, &priv->state)) | |
| 195 | + goto out; | |
| 196 | + | |
| 197 | + err = mlx5e_safe_reopen_channels(priv); | |
| 198 | + | |
| 199 | +out: | |
| 195 | 200 | mutex_unlock(&priv->state_lock); |
| 196 | 201 | rtnl_unlock(); |
| 197 | 202 | |
| @@ -39,6 +39,10 @@ static int get_route_and_out_devs(struct mlx5e_priv *priv, · 38 unmodified lines | ||
| 39 | 39 | return -EOPNOTSUPP; |
| 40 | 40 | } |
| 41 | 41 | |
| 42 | + if (!(mlx5e_eswitch_rep(*out_dev) && | |
| 43 | + mlx5e_is_uplink_rep(netdev_priv(*out_dev)))) | |
| 44 | + return -EOPNOTSUPP; | |
| 45 | + | |
| 42 | 46 | return 0; |
| 43 | 47 | } |
| 44 | 48 | |
| @@ -1768,7 +1768,8 @@ static int set_pflag_rx_no_csum_complete(struct net_device *netdev, bool enable) · 1767 unmodified lines | ||
| 1768 | 1768 | struct mlx5e_channel *c; |
| 1769 | 1769 | int i; |
| 1770 | 1770 | |
| 1771 | − if (!test_bit(MLX5E_STATE_OPENED, &priv->state)) | |
| 1771 | + if (!test_bit(MLX5E_STATE_OPENED, &priv->state) || | |
| 1772 | + priv->channels.params.xdp_prog) | |
| 1772 | 1773 | return 0; |
| 1773 | 1774 | |
| 1774 | 1775 | for (i = 0; i < channels->num; i++) { |
| @@ -952,7 +952,11 @@ static int mlx5e_open_rq(struct mlx5e_channel *c, · 951 unmodified lines | ||
| 952 | 952 | if (params->rx_dim_enabled) |
| 953 | 953 | __set_bit(MLX5E_RQ_STATE_AM, &c->rq.state); |
| 954 | 954 | |
| 955 | − if (MLX5E_GET_PFLAG(params, MLX5E_PFLAG_RX_NO_CSUM_COMPLETE)) | |
| 955 | + /* We disable csum_complete when XDP is enabled since | |
| 956 | + * XDP programs might manipulate packets which will render | |
| 957 | + * skb->checksum incorrect. | |
| 958 | + */ | |
| 959 | + if (MLX5E_GET_PFLAG(params, MLX5E_PFLAG_RX_NO_CSUM_COMPLETE) || c->xdp) | |
| 956 | 960 | __set_bit(MLX5E_RQ_STATE_NO_CSUM_COMPLETE, &c->rq.state); |
| 957 | 961 | |
| 958 | 962 | return 0; |
| @@ -2956,6 +2960,14 @@ int mlx5e_safe_switch_channels(struct mlx5e_priv *priv, · 1997 unmodified lines | ||
| 2956 | 2960 | return 0; |
| 2957 | 2961 | } |
| 2958 | 2962 | |
| 2963 | +int mlx5e_safe_reopen_channels(struct mlx5e_priv *priv) | |
| 2964 | +{ | |
| 2965 | + struct mlx5e_channels new_channels = {}; | |
| 2966 | + | |
| 2967 | + new_channels.params = priv->channels.params; | |
| 2968 | + return mlx5e_safe_switch_channels(priv, &new_channels, NULL); | |
| 2969 | +} | |
| 2970 | + | |
| 2959 | 2971 | void mlx5e_timestamp_init(struct mlx5e_priv *priv) |
| 2960 | 2972 | { |
| 2961 | 2973 | priv->tstamp.tx_type = HWTSTAMP_TX_OFF; |
| @@ -4186,11 +4198,10 @@ static void mlx5e_tx_timeout_work(struct work_struct *work) · 1224 unmodified lines | ||
| 4186 | 4198 | if (!report_failed) |
| 4187 | 4199 | goto unlock; |
| 4188 | 4200 | |
| 4189 | − mlx5e_close_locked(priv->netdev); | |
| 4190 | − err = mlx5e_open_locked(priv->netdev); | |
| 4201 | + err = mlx5e_safe_reopen_channels(priv); | |
| 4191 | 4202 | if (err) |
| 4192 | 4203 | netdev_err(priv->netdev, |
| 4193 | − "mlx5e_open_locked failed recovering from a tx_timeout, err(%d).\n", | |
| 4204 | + "mlx5e_safe_reopen_channels failed recovering from a tx_timeout, err(%d).\n", | |
| 4194 | 4205 | err); |
| 4195 | 4206 | |
| 4196 | 4207 | unlock: |
| @@ -4578,7 +4589,7 @@ void mlx5e_build_rss_params(struct mlx5e_rss_params *rss_params, · 381 unmodified lines | ||
| 4578 | 4589 | { |
| 4579 | 4590 | enum mlx5e_traffic_types tt; |
| 4580 | 4591 | |
| 4581 | − rss_params->hfunc = ETH_RSS_HASH_XOR; | |
| 4592 | + rss_params->hfunc = ETH_RSS_HASH_TOP; | |
| 4582 | 4593 | netdev_rss_key_fill(rss_params->toeplitz_hash_key, |
| 4583 | 4594 | sizeof(rss_params->toeplitz_hash_key)); |
| 4584 | 4595 | mlx5e_build_default_indir_rqt(rss_params->indirection_rqt, |
| @@ -692,7 +692,14 @@ static inline bool is_last_ethertype_ip(struct sk_buff *skb, int *network_depth, · 691 unmodified lines | ||
| 692 | 692 | { |
| 693 | 693 | *proto = ((struct ethhdr *)skb->data)->h_proto; |
| 694 | 694 | *proto = __vlan_get_protocol(skb, *proto, network_depth); |
| 695 | − return (*proto == htons(ETH_P_IP) || *proto == htons(ETH_P_IPV6)); | |
| 695 | + | |
| 696 | + if (*proto == htons(ETH_P_IP)) | |
| 697 | + return pskb_may_pull(skb, *network_depth + sizeof(struct iphdr)); | |
| 698 | + | |
| 699 | + if (*proto == htons(ETH_P_IPV6)) | |
| 700 | + return pskb_may_pull(skb, *network_depth + sizeof(struct ipv6hdr)); | |
| 701 | + | |
| 702 | + return false; | |
| 696 | 703 | } |
| 697 | 704 | |
| 698 | 705 | static inline void mlx5e_enable_ecn(struct mlx5e_rq *rq, struct sk_buff *skb) |
| @@ -712,17 +719,6 @@ static inline void mlx5e_enable_ecn(struct mlx5e_rq *rq, struct sk_buff *skb) · 13 unmodified lines | ||
| 712 | 719 | rq->stats->ecn_mark += !!rc; |
| 713 | 720 | } |
| 714 | 721 | |
| 715 | −static u32 mlx5e_get_fcs(const struct sk_buff *skb) | |
| 716 | −{ | |
| 717 | − const void *fcs_bytes; | |
| 718 | − u32 _fcs_bytes; | |
| 719 | − | |
| 720 | − fcs_bytes = skb_header_pointer(skb, skb->len - ETH_FCS_LEN, | |
| 721 | − ETH_FCS_LEN, &_fcs_bytes); | |
| 722 | − | |
| 723 | − return __get_unaligned_cpu32(fcs_bytes); | |
| 724 | −} | |
| 725 | − | |
| 726 | 722 | static u8 get_ip_proto(struct sk_buff *skb, int network_depth, __be16 proto) |
| 727 | 723 | { |
| 728 | 724 | void *ip_p = skb->data + network_depth; |
| @@ -733,6 +729,68 @@ static u8 get_ip_proto(struct sk_buff *skb, int network_depth, __be16 proto) · 4 unmodified lines | ||
| 733 | 729 | |
| 734 | 730 | #define short_frame(size) ((size) <= ETH_ZLEN + ETH_FCS_LEN) |
| 735 | 731 | |
| 732 | +#define MAX_PADDING 8 | |
| 733 | + | |
| 734 | +static void | |
| 735 | +tail_padding_csum_slow(struct sk_buff *skb, int offset, int len, | |
| 736 | + struct mlx5e_rq_stats *stats) | |
| 737 | +{ | |
| 738 | + stats->csum_complete_tail_slow++; | |
| 739 | + skb->csum = csum_block_add(skb->csum, | |
| 740 | + skb_checksum(skb, offset, len, 0), | |
| 741 | + offset); | |
| 742 | +} | |
| 743 | + | |
| 744 | +static void | |
| 745 | +tail_padding_csum(struct sk_buff *skb, int offset, | |
| 746 | + struct mlx5e_rq_stats *stats) | |
| 747 | +{ | |
| 748 | + u8 tail_padding[MAX_PADDING]; | |
| 749 | + int len = skb->len - offset; | |
| 750 | + void *tail; | |
| 751 | + | |
| 752 | + if (unlikely(len > MAX_PADDING)) { | |
| 753 | + tail_padding_csum_slow(skb, offset, len, stats); | |
| 754 | + return; | |
| 755 | + } | |
| 756 | + | |
| 757 | + tail = skb_header_pointer(skb, offset, len, tail_padding); | |
| 758 | + if (unlikely(!tail)) { | |
| 759 | + tail_padding_csum_slow(skb, offset, len, stats); | |
| 760 | + return; | |
| 761 | + } | |
| 762 | + | |
| 763 | + stats->csum_complete_tail++; | |
| 764 | + skb->csum = csum_block_add(skb->csum, csum_partial(tail, len, 0), offset); | |
| 765 | +} | |
| 766 | + | |
| 767 | +static void | |
| 768 | +mlx5e_skb_padding_csum(struct sk_buff *skb, int network_depth, __be16 proto, | |
| 769 | + struct mlx5e_rq_stats *stats) | |
| 770 | +{ | |
| 771 | + struct ipv6hdr *ip6; | |
| 772 | + struct iphdr *ip4; | |
| 773 | + int pkt_len; | |
| 774 | + | |
| 775 | + switch (proto) { | |
| 776 | + case htons(ETH_P_IP): | |
| 777 | + ip4 = (struct iphdr *)(skb->data + network_depth); | |
| 778 | + pkt_len = network_depth + ntohs(ip4->tot_len); | |
| 779 | + break; | |
| 780 | + case htons(ETH_P_IPV6): | |
| 781 | + ip6 = (struct ipv6hdr *)(skb->data + network_depth); | |
| 782 | + pkt_len = network_depth + sizeof(*ip6) + ntohs(ip6->payload_len); | |
| 783 | + break; | |
| 784 | + default: | |
| 785 | + return; | |
| 786 | + } | |
| 787 | + | |
| 788 | + if (likely(pkt_len >= skb->len)) | |
| 789 | + return; | |
| 790 | + | |
| 791 | + tail_padding_csum(skb, pkt_len, stats); | |
| 792 | +} | |
| 793 | + | |
| 736 | 794 | static inline void mlx5e_handle_csum(struct net_device *netdev, |
| 737 | 795 | struct mlx5_cqe64 *cqe, |
| 738 | 796 | struct mlx5e_rq *rq, |
| @@ -752,7 +810,8 @@ static inline void mlx5e_handle_csum(struct net_device *netdev, · 13 unmodified lines | ||
| 752 | 810 | return; |
| 753 | 811 | } |
| 754 | 812 | |
| 755 | − if (unlikely(test_bit(MLX5E_RQ_STATE_NO_CSUM_COMPLETE, &rq->state))) | |
| 813 | + /* True when explicitly set via priv flag, or XDP prog is loaded */ | |
| 814 | + if (test_bit(MLX5E_RQ_STATE_NO_CSUM_COMPLETE, &rq->state)) | |
| 756 | 815 | goto csum_unnecessary; |
| 757 | 816 | |
| 758 | 817 | /* CQE csum doesn't cover padding octets in short ethernet |
| @@ -780,18 +839,15 @@ static inline void mlx5e_handle_csum(struct net_device *netdev, · 21 unmodified lines | ||
| 780 | 839 | skb->csum = csum_partial(skb->data + ETH_HLEN, |
| 781 | 840 | network_depth - ETH_HLEN, |
| 782 | 841 | skb->csum); |
| 783 | − if (unlikely(netdev->features & NETIF_F_RXFCS)) | |
| 784 | − skb->csum = csum_block_add(skb->csum, | |
| 785 | − (__force __wsum)mlx5e_get_fcs(skb), | |
| 786 | − skb->len - ETH_FCS_LEN); | |
| 842 | + | |
| 843 | + mlx5e_skb_padding_csum(skb, network_depth, proto, stats); | |
| 787 | 844 | stats->csum_complete++; |
| 788 | 845 | return; |
| 789 | 846 | } |
| 790 | 847 | |
| 791 | 848 | csum_unnecessary: |
| 792 | 849 | if (likely((cqe->hds_ip_ext & CQE_L3_OK) && |
| 793 | − ((cqe->hds_ip_ext & CQE_L4_OK) || | |
| 794 | − (get_cqe_l4_hdr_type(cqe) == CQE_L4_HDR_TYPE_NONE)))) { | |
| 850 | + (cqe->hds_ip_ext & CQE_L4_OK))) { | |
| 795 | 851 | skb->ip_summed = CHECKSUM_UNNECESSARY; |
| 796 | 852 | if (cqe_is_tunneled(cqe)) { |
| 797 | 853 | skb->csum_level = 1; |
| @@ -59,6 +59,8 @@ static const struct counter_desc sw_stats_desc[] = { · 58 unmodified lines | ||
| 59 | 59 | { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_unnecessary) }, |
| 60 | 60 | { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_none) }, |
| 61 | 61 | { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_complete) }, |
| 62 | + { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_complete_tail) }, | |
| 63 | + { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_complete_tail_slow) }, | |
| 62 | 64 | { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_unnecessary_inner) }, |
| 63 | 65 | { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_xdp_drop) }, |
| 64 | 66 | { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_xdp_redirect) }, |
| @@ -151,6 +153,8 @@ static void mlx5e_grp_sw_update_stats(struct mlx5e_priv *priv) · 86 unmodified lines | ||
| 151 | 153 | s->rx_removed_vlan_packets += rq_stats->removed_vlan_packets; |
| 152 | 154 | s->rx_csum_none += rq_stats->csum_none; |
| 153 | 155 | s->rx_csum_complete += rq_stats->csum_complete; |
| 156 | + s->rx_csum_complete_tail += rq_stats->csum_complete_tail; | |
| 157 | + s->rx_csum_complete_tail_slow += rq_stats->csum_complete_tail_slow; | |
| 154 | 158 | s->rx_csum_unnecessary += rq_stats->csum_unnecessary; |
| 155 | 159 | s->rx_csum_unnecessary_inner += rq_stats->csum_unnecessary_inner; |
| 156 | 160 | s->rx_xdp_drop += rq_stats->xdp_drop; |
| @@ -1190,6 +1194,8 @@ static const struct counter_desc rq_stats_desc[] = { · 1033 unmodified lines | ||
| 1190 | 1194 | { MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, packets) }, |
| 1191 | 1195 | { MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, bytes) }, |
| 1192 | 1196 | { MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, csum_complete) }, |
| 1197 | + { MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, csum_complete_tail) }, | |
| 1198 | + { MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, csum_complete_tail_slow) }, | |
| 1193 | 1199 | { MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, csum_unnecessary) }, |
| 1194 | 1200 | { MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, csum_unnecessary_inner) }, |
| 1195 | 1201 | { MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, csum_none) }, |
| @@ -71,6 +71,8 @@ struct mlx5e_sw_stats { · 70 unmodified lines | ||
| 71 | 71 | u64 rx_csum_unnecessary; |
| 72 | 72 | u64 rx_csum_none; |
| 73 | 73 | u64 rx_csum_complete; |
| 74 | + u64 rx_csum_complete_tail; | |
| 75 | + u64 rx_csum_complete_tail_slow; | |
| 74 | 76 | u64 rx_csum_unnecessary_inner; |
| 75 | 77 | u64 rx_xdp_drop; |
| 76 | 78 | u64 rx_xdp_redirect; |
| @@ -181,6 +183,8 @@ struct mlx5e_rq_stats { · 104 unmodified lines | ||
| 181 | 183 | u64 packets; |
| 182 | 184 | u64 bytes; |
| 183 | 185 | u64 csum_complete; |
| 186 | + u64 csum_complete_tail; | |
| 187 | + u64 csum_complete_tail_slow; | |
| 184 | 188 | u64 csum_unnecessary; |
| 185 | 189 | u64 csum_unnecessary_inner; |
| 186 | 190 | u64 csum_none; |
| @@ -148,14 +148,16 @@ static int mlx5_fpga_tls_alloc_swid(struct idr *idr, spinlock_t *idr_spinlock, · 147 unmodified lines | ||
| 148 | 148 | return ret; |
| 149 | 149 | } |
| 150 | 150 | |
| 151 | −static void mlx5_fpga_tls_release_swid(struct idr *idr, | |
| 152 | − spinlock_t *idr_spinlock, u32 swid) | |
| 151 | +static void *mlx5_fpga_tls_release_swid(struct idr *idr, | |
| 152 | + spinlock_t *idr_spinlock, u32 swid) | |
| 153 | 153 | { |
| 154 | 154 | unsigned long flags; |
| 155 | + void *ptr; | |
| 155 | 156 | |
| 156 | 157 | spin_lock_irqsave(idr_spinlock, flags); |
| 157 | − idr_remove(idr, swid); | |
| 158 | + ptr = idr_remove(idr, swid); | |
| 158 | 159 | spin_unlock_irqrestore(idr_spinlock, flags); |
| 160 | + return ptr; | |
| 159 | 161 | } |
| 160 | 162 | |
| 161 | 163 | static void mlx_tls_kfree_complete(struct mlx5_fpga_conn *conn, |
| @@ -165,20 +167,12 @@ static void mlx_tls_kfree_complete(struct mlx5_fpga_conn *conn, · 3 unmodified lines | ||
| 165 | 167 | kfree(buf); |
| 166 | 168 | } |
| 167 | 169 | |
| 168 | −struct mlx5_teardown_stream_context { | |
| 169 | − struct mlx5_fpga_tls_command_context cmd; | |
| 170 | − u32 swid; | |
| 171 | −}; | |
| 172 | − | |
| 173 | 170 | static void |
| 174 | 171 | mlx5_fpga_tls_teardown_completion(struct mlx5_fpga_conn *conn, |
| 175 | 172 | struct mlx5_fpga_device *fdev, |
| 176 | 173 | struct mlx5_fpga_tls_command_context *cmd, |
| 177 | 174 | struct mlx5_fpga_dma_buf *resp) |
| 178 | 175 | { |
| 179 | − struct mlx5_teardown_stream_context *ctx = | |
| 180 | − container_of(cmd, struct mlx5_teardown_stream_context, cmd); | |
| 181 | − | |
| 182 | 176 | if (resp) { |
| 183 | 177 | u32 syndrome = MLX5_GET(tls_resp, resp->sg[0].data, syndrome); |
| 184 | 178 | |
| @@ -186,14 +180,6 @@ mlx5_fpga_tls_teardown_completion(struct mlx5_fpga_conn *conn, · 1 unmodified line | ||
| 186 | 180 | mlx5_fpga_err(fdev, |
| 187 | 181 | "Teardown stream failed with syndrome = %d", |
| 188 | 182 | syndrome); |
| 189 | − else if (MLX5_GET(tls_cmd, cmd->buf.sg[0].data, direction_sx)) | |
| 190 | − mlx5_fpga_tls_release_swid(&fdev->tls->tx_idr, | |
| 191 | − &fdev->tls->tx_idr_spinlock, | |
| 192 | − ctx->swid); | |
| 193 | − else | |
| 194 | − mlx5_fpga_tls_release_swid(&fdev->tls->rx_idr, | |
| 195 | − &fdev->tls->rx_idr_spinlock, | |
| 196 | − ctx->swid); | |
| 197 | 183 | } |
| 198 | 184 | mlx5_fpga_tls_put_command_ctx(cmd); |
| 199 | 185 | } |
| @@ -217,22 +203,22 @@ int mlx5_fpga_tls_resync_rx(struct mlx5_core_dev *mdev, u32 handle, u32 seq, · 17 unmodified lines | ||
| 217 | 203 | void *cmd; |
| 218 | 204 | int ret; |
| 219 | 205 | |
| 220 | − rcu_read_lock(); | |
| 221 | − flow = idr_find(&mdev->fpga->tls->rx_idr, ntohl(handle)); | |
| 222 | − rcu_read_unlock(); | |
| 223 | − | |
| 224 | − if (!flow) { | |
| 225 | − WARN_ONCE(1, "Received NULL pointer for handle\n"); | |
| 226 | − return -EINVAL; | |
| 227 | − } | |
| 228 | − | |
| 229 | 206 | buf = kzalloc(size, GFP_ATOMIC); |
| 230 | 207 | if (!buf) |
| 231 | 208 | return -ENOMEM; |
| 232 | 209 | |
| 233 | 210 | cmd = (buf + 1); |
| 234 | 211 | |
| 212 | + rcu_read_lock(); | |
| 213 | + flow = idr_find(&mdev->fpga->tls->rx_idr, ntohl(handle)); | |
| 214 | + if (unlikely(!flow)) { | |
| 215 | + rcu_read_unlock(); | |
| 216 | + WARN_ONCE(1, "Received NULL pointer for handle\n"); | |
| 217 | + kfree(buf); | |
| 218 | + return -EINVAL; | |
| 219 | + } | |
| 235 | 220 | mlx5_fpga_tls_flow_to_cmd(flow, cmd); |
| 221 | + rcu_read_unlock(); | |
| 236 | 222 | |
| 237 | 223 | MLX5_SET(tls_cmd, cmd, swid, ntohl(handle)); |
| 238 | 224 | MLX5_SET64(tls_cmd, cmd, tls_rcd_sn, be64_to_cpu(rcd_sn)); |
| @@ -253,7 +239,7 @@ int mlx5_fpga_tls_resync_rx(struct mlx5_core_dev *mdev, u32 handle, u32 seq, · 14 unmodified lines | ||
| 253 | 239 | static void mlx5_fpga_tls_send_teardown_cmd(struct mlx5_core_dev *mdev, |
| 254 | 240 | void *flow, u32 swid, gfp_t flags) |
| 255 | 241 | { |
| 256 | − struct mlx5_teardown_stream_context *ctx; | |
| 242 | + struct mlx5_fpga_tls_command_context *ctx; | |
| 257 | 243 | struct mlx5_fpga_dma_buf *buf; |
| 258 | 244 | void *cmd; |
| 259 | 245 | |
| @@ -261,7 +247,7 @@ static void mlx5_fpga_tls_send_teardown_cmd(struct mlx5_core_dev *mdev, · 1 unmodified line | ||
| 261 | 247 | if (!ctx) |
| 262 | 248 | return; |
| 263 | 249 | |
| 264 | − buf = &ctx->cmd.buf; | |
| 250 | + buf = &ctx->buf; | |
| 265 | 251 | cmd = (ctx + 1); |
| 266 | 252 | MLX5_SET(tls_cmd, cmd, command_type, CMD_TEARDOWN_STREAM); |
| 267 | 253 | MLX5_SET(tls_cmd, cmd, swid, swid); |
| @@ -272,8 +258,7 @@ static void mlx5_fpga_tls_send_teardown_cmd(struct mlx5_core_dev *mdev, · 4 unmodified lines | ||
| 272 | 258 | buf->sg[0].data = cmd; |
| 273 | 259 | buf->sg[0].size = MLX5_TLS_COMMAND_SIZE; |
| 274 | 260 | |
| 275 | − ctx->swid = swid; | |
| 276 | − mlx5_fpga_tls_cmd_send(mdev->fpga, &ctx->cmd, | |
| 261 | + mlx5_fpga_tls_cmd_send(mdev->fpga, ctx, | |
| 277 | 262 | mlx5_fpga_tls_teardown_completion); |
| 278 | 263 | } |
| 279 | 264 | |
| @@ -283,13 +268,14 @@ void mlx5_fpga_tls_del_flow(struct mlx5_core_dev *mdev, u32 swid, · 3 unmodified lines | ||
| 283 | 268 | struct mlx5_fpga_tls *tls = mdev->fpga->tls; |
| 284 | 269 | void *flow; |
| 285 | 270 | |
| 286 | − rcu_read_lock(); | |
| 287 | 271 | if (direction_sx) |
| 288 | − flow = idr_find(&tls->tx_idr, swid); | |
| 272 | + flow = mlx5_fpga_tls_release_swid(&tls->tx_idr, | |
| 273 | + &tls->tx_idr_spinlock, | |
| 274 | + swid); | |
| 289 | 275 | else |
| 290 | − flow = idr_find(&tls->rx_idr, swid); | |
| 291 | − | |
| 292 | − rcu_read_unlock(); | |
| 276 | + flow = mlx5_fpga_tls_release_swid(&tls->rx_idr, | |
| 277 | + &tls->rx_idr_spinlock, | |
| 278 | + swid); | |
| 293 | 279 | |
| 294 | 280 | if (!flow) { |
| 295 | 281 | mlx5_fpga_err(mdev->fpga, "No flow information for swid %u\n", |
| @@ -297,6 +283,7 @@ void mlx5_fpga_tls_del_flow(struct mlx5_core_dev *mdev, u32 swid, · 1 unmodified line | ||
| 297 | 283 | return; |
| 298 | 284 | } |
| 299 | 285 | |
| 286 | + synchronize_rcu(); /* before kfree(flow) */ | |
| 300 | 287 | mlx5_fpga_tls_send_teardown_cmd(mdev, flow, swid, flags); |
| 301 | 288 | } |
| 302 | 289 | |
| @@ -568,7 +568,7 @@ static int mlxsw_emad_init(struct mlxsw_core *mlxsw_core) · 567 unmodified lines | ||
| 568 | 568 | if (!(mlxsw_core->bus->features & MLXSW_BUS_F_TXRX)) |
| 569 | 569 | return 0; |
| 570 | 570 | |
| 571 | − emad_wq = alloc_workqueue("mlxsw_core_emad", WQ_MEM_RECLAIM, 0); | |
| 571 | + emad_wq = alloc_workqueue("mlxsw_core_emad", 0, 0); | |
| 572 | 572 | if (!emad_wq) |
| 573 | 573 | return -ENOMEM; |
| 574 | 574 | mlxsw_core->emad_wq = emad_wq; |
| @@ -2004,10 +2004,10 @@ static int __init mlxsw_core_module_init(void) · 1429 unmodified lines | ||
| 2004 | 2004 | { |
| 2005 | 2005 | int err; |
| 2006 | 2006 | |
| 2007 | − mlxsw_wq = alloc_workqueue(mlxsw_core_driver_name, WQ_MEM_RECLAIM, 0); | |
| 2007 | + mlxsw_wq = alloc_workqueue(mlxsw_core_driver_name, 0, 0); | |
| 2008 | 2008 | if (!mlxsw_wq) |
| 2009 | 2009 | return -ENOMEM; |
| 2010 | − mlxsw_owq = alloc_ordered_workqueue("%s_ordered", WQ_MEM_RECLAIM, | |
| 2010 | + mlxsw_owq = alloc_ordered_workqueue("%s_ordered", 0, | |
| 2011 | 2011 | mlxsw_core_driver_name); |
| 2012 | 2012 | if (!mlxsw_owq) { |
| 2013 | 2013 | err = -ENOMEM; |
| @@ -70,6 +70,7 @@ static const struct mlxsw_sp_sb_pool_des mlxsw_sp2_sb_pool_dess[] = { · 69 unmodified lines | ||
| 70 | 70 | {MLXSW_REG_SBXX_DIR_EGRESS, 1}, |
| 71 | 71 | {MLXSW_REG_SBXX_DIR_EGRESS, 2}, |
| 72 | 72 | {MLXSW_REG_SBXX_DIR_EGRESS, 3}, |
| 73 | + {MLXSW_REG_SBXX_DIR_EGRESS, 15}, | |
| 73 | 74 | }; |
| 74 | 75 | |
| 75 | 76 | #define MLXSW_SP_SB_ING_TC_COUNT 8 |
| @@ -428,6 +429,7 @@ static const struct mlxsw_sp_sb_pr mlxsw_sp2_sb_prs[] = { · 352 unmodified lines | ||
| 428 | 429 | MLXSW_SP_SB_PR(MLXSW_REG_SBPR_MODE_STATIC, 0), |
| 429 | 430 | MLXSW_SP_SB_PR(MLXSW_REG_SBPR_MODE_STATIC, 0), |
| 430 | 431 | MLXSW_SP_SB_PR(MLXSW_REG_SBPR_MODE_STATIC, 0), |
| 432 | + MLXSW_SP_SB_PR(MLXSW_REG_SBPR_MODE_STATIC, MLXSW_SP_SB_INFI), | |
| 431 | 433 | }; |
| 432 | 434 | |
| 433 | 435 | static int mlxsw_sp_sb_prs_init(struct mlxsw_sp *mlxsw_sp, |
| @@ -517,14 +519,14 @@ static const struct mlxsw_sp_sb_cm mlxsw_sp2_sb_cms_egress[] = { · 83 unmodified lines | ||
| 517 | 519 | MLXSW_SP_SB_CM(0, 7, 4), |
| 518 | 520 | MLXSW_SP_SB_CM(0, 7, 4), |
| 519 | 521 | MLXSW_SP_SB_CM(0, 7, 4), |
| 520 | − MLXSW_SP_SB_CM(0, 7, 4), | |
| 521 | − MLXSW_SP_SB_CM(0, 7, 4), | |
| 522 | − MLXSW_SP_SB_CM(0, 7, 4), | |
| 523 | − MLXSW_SP_SB_CM(0, 7, 4), | |
| 524 | − MLXSW_SP_SB_CM(0, 7, 4), | |
| 525 | − MLXSW_SP_SB_CM(0, 7, 4), | |
| 526 | − MLXSW_SP_SB_CM(0, 7, 4), | |
| 527 | − MLXSW_SP_SB_CM(0, 7, 4), | |
| 522 | + MLXSW_SP_SB_CM(0, MLXSW_SP_SB_INFI, 8), | |
| 523 | + MLXSW_SP_SB_CM(0, MLXSW_SP_SB_INFI, 8), | |
| 524 | + MLXSW_SP_SB_CM(0, MLXSW_SP_SB_INFI, 8), | |
| 525 | + MLXSW_SP_SB_CM(0, MLXSW_SP_SB_INFI, 8), | |
| 526 | + MLXSW_SP_SB_CM(0, MLXSW_SP_SB_INFI, 8), | |
| 527 | + MLXSW_SP_SB_CM(0, MLXSW_SP_SB_INFI, 8), | |
| 528 | + MLXSW_SP_SB_CM(0, MLXSW_SP_SB_INFI, 8), | |
| 529 | + MLXSW_SP_SB_CM(0, MLXSW_SP_SB_INFI, 8), | |
| 528 | 530 | MLXSW_SP_SB_CM(1, 0xff, 4), |
| 529 | 531 | }; |
| 530 | 532 | |
| @@ -671,6 +673,7 @@ static const struct mlxsw_sp_sb_pm mlxsw_sp2_sb_pms[] = { · 140 unmodified lines | ||
| 671 | 673 | MLXSW_SP_SB_PM(0, 0), |
| 672 | 674 | MLXSW_SP_SB_PM(0, 0), |
| 673 | 675 | MLXSW_SP_SB_PM(0, 0), |
| 676 | + MLXSW_SP_SB_PM(10000, 90000), | |
| 674 | 677 | }; |
| 675 | 678 | |
| 676 | 679 | static int mlxsw_sp_port_sb_pms_init(struct mlxsw_sp_port *mlxsw_sp_port) |
| @@ -6804,7 +6804,7 @@ static int mlxsw_sp_router_port_check_rif_addr(struct mlxsw_sp *mlxsw_sp, · 6803 unmodified lines | ||
| 6804 | 6804 | /* A RIF is not created for macvlan netdevs. Their MAC is used to |
| 6805 | 6805 | * populate the FDB |
| 6806 | 6806 | */ |
| 6807 | − if (netif_is_macvlan(dev)) | |
| 6807 | + if (netif_is_macvlan(dev) || netif_is_l3_master(dev)) | |
| 6808 | 6808 | return 0; |
| 6809 | 6809 | |
| 6810 | 6810 | for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++) { |
| @@ -1630,7 +1630,7 @@ static int mlxsw_sp_port_mdb_add(struct mlxsw_sp_port *mlxsw_sp_port, · 1629 unmodified lines | ||
| 1630 | 1630 | u16 fid_index; |
| 1631 | 1631 | int err = 0; |
| 1632 | 1632 | |
| 1633 | − if (switchdev_trans_ph_prepare(trans)) | |
| 1633 | + if (switchdev_trans_ph_commit(trans)) | |
| 1634 | 1634 | return 0; |
| 1635 | 1635 | |
| 1636 | 1636 | bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev); |
| @@ -613,7 +613,7 @@ static int ocelot_mact_mc_add(struct ocelot_port *port, · 612 unmodified lines | ||
| 613 | 613 | struct netdev_hw_addr *hw_addr) |
| 614 | 614 | { |
| 615 | 615 | struct ocelot *ocelot = port->ocelot; |
| 616 | − struct netdev_hw_addr *ha = kzalloc(sizeof(*ha), GFP_KERNEL); | |
| 616 | + struct netdev_hw_addr *ha = kzalloc(sizeof(*ha), GFP_ATOMIC); | |
| 617 | 617 | |
| 618 | 618 | if (!ha) |
| 619 | 619 | return -ENOMEM; |
| @@ -959,10 +959,8 @@ static void ocelot_get_strings(struct net_device *netdev, u32 sset, u8 *data) · 339 unmodified lines | ||
| 959 | 959 | ETH_GSTRING_LEN); |
| 960 | 960 | } |
| 961 | 961 | |
| 962 | −static void ocelot_check_stats(struct work_struct *work) | |
| 962 | +static void ocelot_update_stats(struct ocelot *ocelot) | |
| 963 | 963 | { |
| 964 | − struct delayed_work *del_work = to_delayed_work(work); | |
| 965 | − struct ocelot *ocelot = container_of(del_work, struct ocelot, stats_work); | |
| 966 | 964 | int i, j; |
| 967 | 965 | |
| 968 | 966 | mutex_lock(&ocelot->stats_lock); |
| @@ -986,11 +984,19 @@ static void ocelot_check_stats(struct work_struct *work) · 17 unmodified lines | ||
| 986 | 984 | } |
| 987 | 985 | } |
| 988 | 986 | |
| 989 | − cancel_delayed_work(&ocelot->stats_work); | |
| 987 | + mutex_unlock(&ocelot->stats_lock); | |
| 988 | +} | |
| 989 | + | |
| 990 | +static void ocelot_check_stats_work(struct work_struct *work) | |
| 991 | +{ | |
| 992 | + struct delayed_work *del_work = to_delayed_work(work); | |
| 993 | + struct ocelot *ocelot = container_of(del_work, struct ocelot, | |
| 994 | + stats_work); | |
| 995 | + | |
| 996 | + ocelot_update_stats(ocelot); | |
| 997 | + | |
| 990 | 998 | queue_delayed_work(ocelot->stats_queue, &ocelot->stats_work, |
| 991 | 999 | OCELOT_STATS_CHECK_DELAY); |
| 992 | − | |
| 993 | − mutex_unlock(&ocelot->stats_lock); | |
| 994 | 1000 | } |
| 995 | 1001 | |
| 996 | 1002 | static void ocelot_get_ethtool_stats(struct net_device *dev, |
| @@ -1001,7 +1007,7 @@ static void ocelot_get_ethtool_stats(struct net_device *dev, · 4 unmodified lines | ||
| 1001 | 1007 | int i; |
| 1002 | 1008 | |
| 1003 | 1009 | /* check and update now */ |
| 1004 | − ocelot_check_stats(&ocelot->stats_work.work); | |
| 1010 | + ocelot_update_stats(ocelot); | |
| 1005 | 1011 | |
| 1006 | 1012 | /* Copy all counters */ |
| 1007 | 1013 | for (i = 0; i < ocelot->num_stats; i++) |
| @@ -1809,7 +1815,7 @@ int ocelot_init(struct ocelot *ocelot) · 801 unmodified lines | ||
| 1809 | 1815 | ANA_CPUQ_8021_CFG_CPUQ_BPDU_VAL(6), |
| 1810 | 1816 | ANA_CPUQ_8021_CFG, i); |
| 1811 | 1817 | |
| 1812 | − INIT_DELAYED_WORK(&ocelot->stats_work, ocelot_check_stats); | |
| 1818 | + INIT_DELAYED_WORK(&ocelot->stats_work, ocelot_check_stats_work); | |
| 1813 | 1819 | queue_delayed_work(ocelot->stats_queue, &ocelot->stats_work, |
| 1814 | 1820 | OCELOT_STATS_CHECK_DELAY); |
| 1815 | 1821 | return 0; |
| @@ -2366,6 +2366,7 @@ static void *__vxge_hw_blockpool_malloc(struct __vxge_hw_device *devh, u32 size, · 2365 unmodified lines | ||
| 2366 | 2366 | dma_object->addr))) { |
| 2367 | 2367 | vxge_os_dma_free(devh->pdev, memblock, |
| 2368 | 2368 | &dma_object->acc_handle); |
| 2369 | + memblock = NULL; | |
| 2369 | 2370 | goto exit; |
| 2370 | 2371 | } |
| 2371 | 2372 | |
| @@ -431,12 +431,16 @@ struct qed_qm_info { · 430 unmodified lines | ||
| 431 | 431 | u8 num_pf_rls; |
| 432 | 432 | }; |
| 433 | 433 | |
| 434 | +#define QED_OVERFLOW_BIT 1 | |
| 435 | + | |
| 434 | 436 | struct qed_db_recovery_info { |
| 435 | 437 | struct list_head list; |
| 436 | 438 | |
| 437 | 439 | /* Lock to protect the doorbell recovery mechanism list */ |
| 438 | 440 | spinlock_t lock; |
| 441 | + bool dorq_attn; | |
| 439 | 442 | u32 db_recovery_counter; |
| 443 | + unsigned long overflow; | |
| 440 | 444 | }; |
| 441 | 445 | |
| 442 | 446 | struct storm_stats { |
| @@ -923,8 +927,7 @@ u16 qed_get_cm_pq_idx_llt_mtc(struct qed_hwfn *p_hwfn, u8 tc); · 480 unmodified lines | ||
| 923 | 927 | |
| 924 | 928 | /* doorbell recovery mechanism */ |
| 925 | 929 | void qed_db_recovery_dp(struct qed_hwfn *p_hwfn); |
| 926 | −void qed_db_recovery_execute(struct qed_hwfn *p_hwfn, | |
| 927 | − enum qed_db_rec_exec db_exec); | |
| 930 | +void qed_db_recovery_execute(struct qed_hwfn *p_hwfn); | |
| 928 | 931 | bool qed_edpm_enabled(struct qed_hwfn *p_hwfn); |
| 929 | 932 | |
| 930 | 933 | /* Other Linux specific common definitions */ |
| @@ -102,11 +102,15 @@ static void qed_db_recovery_dp_entry(struct qed_hwfn *p_hwfn, · 101 unmodified lines | ||
| 102 | 102 | |
| 103 | 103 | /* Doorbell address sanity (address within doorbell bar range) */ |
| 104 | 104 | static bool qed_db_rec_sanity(struct qed_dev *cdev, |
| 105 | − void __iomem *db_addr, void *db_data) | |
| 105 | + void __iomem *db_addr, | |
| 106 | + enum qed_db_rec_width db_width, | |
| 107 | + void *db_data) | |
| 106 | 108 | { |
| 109 | + u32 width = (db_width == DB_REC_WIDTH_32B) ? 32 : 64; | |
| 110 | + | |
| 107 | 111 | /* Make sure doorbell address is within the doorbell bar */ |
| 108 | 112 | if (db_addr < cdev->doorbells || |
| 109 | − (u8 __iomem *)db_addr > | |
| 113 | + (u8 __iomem *)db_addr + width > | |
| 110 | 114 | (u8 __iomem *)cdev->doorbells + cdev->db_size) { |
| 111 | 115 | WARN(true, |
| 112 | 116 | "Illegal doorbell address: %p. Legal range for doorbell addresses is [%p..%p]\n", |
| @@ -159,7 +163,7 @@ int qed_db_recovery_add(struct qed_dev *cdev, · 46 unmodified lines | ||
| 159 | 163 | } |
| 160 | 164 | |
| 161 | 165 | /* Sanitize doorbell address */ |
| 162 | − if (!qed_db_rec_sanity(cdev, db_addr, db_data)) | |
| 166 | + if (!qed_db_rec_sanity(cdev, db_addr, db_width, db_data)) | |
| 163 | 167 | return -EINVAL; |
| 164 | 168 | |
| 165 | 169 | /* Obtain hwfn from doorbell address */ |
| @@ -205,10 +209,6 @@ int qed_db_recovery_del(struct qed_dev *cdev, · 39 unmodified lines | ||
| 205 | 209 | return 0; |
| 206 | 210 | } |
| 207 | 211 | |
| 208 | − /* Sanitize doorbell address */ | |
| 209 | − if (!qed_db_rec_sanity(cdev, db_addr, db_data)) | |
| 210 | − return -EINVAL; | |
| 211 | − | |
| 212 | 212 | /* Obtain hwfn from doorbell address */ |
| 213 | 213 | p_hwfn = qed_db_rec_find_hwfn(cdev, db_addr); |
| 214 | 214 | |
| @@ -300,31 +300,24 @@ void qed_db_recovery_dp(struct qed_hwfn *p_hwfn) · 85 unmodified lines | ||
| 300 | 300 | |
| 301 | 301 | /* Ring the doorbell of a single doorbell recovery entry */ |
| 302 | 302 | static void qed_db_recovery_ring(struct qed_hwfn *p_hwfn, |
| 303 | − struct qed_db_recovery_entry *db_entry, | |
| 304 | − enum qed_db_rec_exec db_exec) | |
| 305 | −{ | |
| 306 | − if (db_exec != DB_REC_ONCE) { | |
| 307 | − /* Print according to width */ | |
| 308 | − if (db_entry->db_width == DB_REC_WIDTH_32B) { | |
| 309 | − DP_VERBOSE(p_hwfn, QED_MSG_SPQ, | |
| 310 | − "%s doorbell address %p data %x\n", | |
| 311 | − db_exec == DB_REC_DRY_RUN ? | |
| 312 | − "would have rung" : "ringing", | |
| 313 | − db_entry->db_addr, | |
| 314 | − *(u32 *)db_entry->db_data); | |
| 315 | − } else { | |
| 316 | − DP_VERBOSE(p_hwfn, QED_MSG_SPQ, | |
| 317 | − "%s doorbell address %p data %llx\n", | |
| 318 | − db_exec == DB_REC_DRY_RUN ? | |
| 319 | − "would have rung" : "ringing", | |
| 320 | − db_entry->db_addr, | |
| 321 | − *(u64 *)(db_entry->db_data)); | |
| 322 | − } | |
| 303 | + struct qed_db_recovery_entry *db_entry) | |
| 304 | +{ | |
| 305 | + /* Print according to width */ | |
| 306 | + if (db_entry->db_width == DB_REC_WIDTH_32B) { | |
| 307 | + DP_VERBOSE(p_hwfn, QED_MSG_SPQ, | |
| 308 | + "ringing doorbell address %p data %x\n", | |
| 309 | + db_entry->db_addr, | |
| 310 | + *(u32 *)db_entry->db_data); | |
| 311 | + } else { | |
| 312 | + DP_VERBOSE(p_hwfn, QED_MSG_SPQ, | |
| 313 | + "ringing doorbell address %p data %llx\n", | |
| 314 | + db_entry->db_addr, | |
| 315 | + *(u64 *)(db_entry->db_data)); | |
| 323 | 316 | } |
| 324 | 317 | |
| 325 | 318 | /* Sanity */ |
| 326 | 319 | if (!qed_db_rec_sanity(p_hwfn->cdev, db_entry->db_addr, |
| 327 | − db_entry->db_data)) | |
| 320 | + db_entry->db_width, db_entry->db_data)) | |
| 328 | 321 | return; |
| 329 | 322 | |
| 330 | 323 | /* Flush the write combined buffer. Since there are multiple doorbelling |
| @@ -334,14 +327,12 @@ static void qed_db_recovery_ring(struct qed_hwfn *p_hwfn, · 3 unmodified lines | ||
| 334 | 327 | wmb(); |
| 335 | 328 | |
| 336 | 329 | /* Ring the doorbell */ |
| 337 | − if (db_exec == DB_REC_REAL_DEAL || db_exec == DB_REC_ONCE) { | |
| 338 | − if (db_entry->db_width == DB_REC_WIDTH_32B) | |
| 339 | − DIRECT_REG_WR(db_entry->db_addr, | |
| 340 | − *(u32 *)(db_entry->db_data)); | |
| 341 | − else | |
| 342 | − DIRECT_REG_WR64(db_entry->db_addr, | |
| 343 | − *(u64 *)(db_entry->db_data)); | |
| 344 | − } | |
| 330 | + if (db_entry->db_width == DB_REC_WIDTH_32B) | |
| 331 | + DIRECT_REG_WR(db_entry->db_addr, | |
| 332 | + *(u32 *)(db_entry->db_data)); | |
| 333 | + else | |
| 334 | + DIRECT_REG_WR64(db_entry->db_addr, | |
| 335 | + *(u64 *)(db_entry->db_data)); | |
| 345 | 336 | |
| 346 | 337 | /* Flush the write combined buffer. Next doorbell may come from a |
| 347 | 338 | * different entity to the same address... |
| @@ -350,29 +341,21 @@ static void qed_db_recovery_ring(struct qed_hwfn *p_hwfn, · 2 unmodified lines | ||
| 350 | 341 | } |
| 351 | 342 | |
| 352 | 343 | /* Traverse the doorbell recovery entry list and ring all the doorbells */ |
| 353 | −void qed_db_recovery_execute(struct qed_hwfn *p_hwfn, | |
| 354 | − enum qed_db_rec_exec db_exec) | |
| 344 | +void qed_db_recovery_execute(struct qed_hwfn *p_hwfn) | |
| 355 | 345 | { |
| 356 | 346 | struct qed_db_recovery_entry *db_entry = NULL; |
| 357 | 347 | |
| 358 | − if (db_exec != DB_REC_ONCE) { | |
| 359 | − DP_NOTICE(p_hwfn, | |
| 360 | − "Executing doorbell recovery. Counter was %d\n", | |
| 361 | − p_hwfn->db_recovery_info.db_recovery_counter); | |
| 348 | + DP_NOTICE(p_hwfn, "Executing doorbell recovery. Counter was %d\n", | |
| 349 | + p_hwfn->db_recovery_info.db_recovery_counter); | |
| 362 | 350 | |
| 363 | − /* Track amount of times recovery was executed */ | |
| 364 | − p_hwfn->db_recovery_info.db_recovery_counter++; | |
| 365 | − } | |
| 351 | + /* Track amount of times recovery was executed */ | |
| 352 | + p_hwfn->db_recovery_info.db_recovery_counter++; | |
| 366 | 353 | |
| 367 | 354 | /* Protect the list */ |
| 368 | 355 | spin_lock_bh(&p_hwfn->db_recovery_info.lock); |
| 369 | 356 | list_for_each_entry(db_entry, |
| 370 | − &p_hwfn->db_recovery_info.list, list_entry) { | |
| 371 | − qed_db_recovery_ring(p_hwfn, db_entry, db_exec); | |
| 372 | − if (db_exec == DB_REC_ONCE) | |
| 373 | − break; | |
| 374 | − } | |
| 375 | − | |
| 357 | + &p_hwfn->db_recovery_info.list, list_entry) | |
| 358 | + qed_db_recovery_ring(p_hwfn, db_entry); | |
| 376 | 359 | spin_unlock_bh(&p_hwfn->db_recovery_info.lock); |
| 377 | 360 | } |
| 378 | 361 | |
| @@ -378,6 +378,9 @@ static int qed_db_rec_flush_queue(struct qed_hwfn *p_hwfn, · 377 unmodified lines | ||
| 378 | 378 | u32 count = QED_DB_REC_COUNT; |
| 379 | 379 | u32 usage = 1; |
| 380 | 380 | |
| 381 | + /* Flush any pending (e)dpms as they may never arrive */ | |
| 382 | + qed_wr(p_hwfn, p_ptt, DORQ_REG_DPM_FORCE_ABORT, 0x1); | |
| 383 | + | |
| 381 | 384 | /* wait for usage to zero or count to run out. This is necessary since |
| 382 | 385 | * EDPM doorbell transactions can take multiple 64b cycles, and as such |
| 383 | 386 | * can "split" over the pci. Possibly, the doorbell drop can happen with |
| @@ -406,51 +409,74 @@ static int qed_db_rec_flush_queue(struct qed_hwfn *p_hwfn, · 22 unmodified lines | ||
| 406 | 409 | |
| 407 | 410 | int qed_db_rec_handler(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt) |
| 408 | 411 | { |
| 409 | − u32 overflow; | |
| 412 | + u32 attn_ovfl, cur_ovfl; | |
| 410 | 413 | int rc; |
| 411 | 414 | |
| 412 | − overflow = qed_rd(p_hwfn, p_ptt, DORQ_REG_PF_OVFL_STICKY); | |
| 413 | − DP_NOTICE(p_hwfn, "PF Overflow sticky 0x%x\n", overflow); | |
| 414 | − if (!overflow) { | |
| 415 | − qed_db_recovery_execute(p_hwfn, DB_REC_ONCE); | |
| 415 | + attn_ovfl = test_and_clear_bit(QED_OVERFLOW_BIT, | |
| 416 | + &p_hwfn->db_recovery_info.overflow); | |
| 417 | + cur_ovfl = qed_rd(p_hwfn, p_ptt, DORQ_REG_PF_OVFL_STICKY); | |
| 418 | + if (!cur_ovfl && !attn_ovfl) | |
| 416 | 419 | return 0; |
| 417 | − } | |
| 418 | 420 | |
| 419 | − if (qed_edpm_enabled(p_hwfn)) { | |
| 421 | + DP_NOTICE(p_hwfn, "PF Overflow sticky: attn %u current %u\n", | |
| 422 | + attn_ovfl, cur_ovfl); | |
| 423 | + | |
| 424 | + if (cur_ovfl && !p_hwfn->db_bar_no_edpm) { | |
| 420 | 425 | rc = qed_db_rec_flush_queue(p_hwfn, p_ptt); |
| 421 | 426 | if (rc) |
| 422 | 427 | return rc; |
| 423 | 428 | } |
| 424 | 429 | |
| 425 | − /* Flush any pending (e)dpm as they may never arrive */ | |
| 426 | − qed_wr(p_hwfn, p_ptt, DORQ_REG_DPM_FORCE_ABORT, 0x1); | |
| 427 | − | |
| 428 | 430 | /* Release overflow sticky indication (stop silently dropping everything) */ |
| 429 | 431 | qed_wr(p_hwfn, p_ptt, DORQ_REG_PF_OVFL_STICKY, 0x0); |
| 430 | 432 | |
| 431 | 433 | /* Repeat all last doorbells (doorbell drop recovery) */ |
| 432 | − qed_db_recovery_execute(p_hwfn, DB_REC_REAL_DEAL); | |
| 434 | + qed_db_recovery_execute(p_hwfn); | |
| 433 | 435 | |
| 434 | 436 | return 0; |
| 435 | 437 | } |
| 436 | 438 | |
| 437 | −static int qed_dorq_attn_cb(struct qed_hwfn *p_hwfn) | |
| 439 | +static void qed_dorq_attn_overflow(struct qed_hwfn *p_hwfn) | |
| 438 | 440 | { |
| 439 | − u32 int_sts, first_drop_reason, details, address, all_drops_reason; | |
| 440 | 441 | struct qed_ptt *p_ptt = p_hwfn->p_dpc_ptt; |
| 442 | + u32 overflow; | |
| 441 | 443 | int rc; |
| 442 | 444 | |
| 443 | − int_sts = qed_rd(p_hwfn, p_ptt, DORQ_REG_INT_STS); | |
| 444 | − DP_NOTICE(p_hwfn->cdev, "DORQ attention. int_sts was %x\n", int_sts); | |
| 445 | + overflow = qed_rd(p_hwfn, p_ptt, DORQ_REG_PF_OVFL_STICKY); | |
| 446 | + if (!overflow) | |
| 447 | + goto out; | |
| 448 | + | |
| 449 | + /* Run PF doorbell recovery in next periodic handler */ | |
| 450 | + set_bit(QED_OVERFLOW_BIT, &p_hwfn->db_recovery_info.overflow); | |
| 451 | + | |
| 452 | + if (!p_hwfn->db_bar_no_edpm) { | |
| 453 | + rc = qed_db_rec_flush_queue(p_hwfn, p_ptt); | |
| 454 | + if (rc) | |
| 455 | + goto out; | |
| 456 | + } | |
| 457 | + | |
| 458 | + qed_wr(p_hwfn, p_ptt, DORQ_REG_PF_OVFL_STICKY, 0x0); | |
| 459 | +out: | |
| 460 | + /* Schedule the handler even if overflow was not detected */ | |
| 461 | + qed_periodic_db_rec_start(p_hwfn); | |
| 462 | +} | |
| 463 | + | |
| 464 | +static int qed_dorq_attn_int_sts(struct qed_hwfn *p_hwfn) | |
| 465 | +{ | |
| 466 | + u32 int_sts, first_drop_reason, details, address, all_drops_reason; | |
| 467 | + struct qed_ptt *p_ptt = p_hwfn->p_dpc_ptt; | |
| 445 | 468 | |
| 446 | 469 | /* int_sts may be zero since all PFs were interrupted for doorbell |
| 447 | 470 | * overflow but another one already handled it. Can abort here. If |
| 448 | 471 | * This PF also requires overflow recovery we will be interrupted again. |
| 449 | 472 | * The masked almost full indication may also be set. Ignoring. |
| 450 | 473 | */ |
| 474 | + int_sts = qed_rd(p_hwfn, p_ptt, DORQ_REG_INT_STS); | |
| 451 | 475 | if (!(int_sts & ~DORQ_REG_INT_STS_DORQ_FIFO_AFULL)) |
| 452 | 476 | return 0; |
| 453 | 477 | |
| 478 | + DP_NOTICE(p_hwfn->cdev, "DORQ attention. int_sts was %x\n", int_sts); | |
| 479 | + | |
| 454 | 480 | /* check if db_drop or overflow happened */ |
| 455 | 481 | if (int_sts & (DORQ_REG_INT_STS_DB_DROP | |
| 456 | 482 | DORQ_REG_INT_STS_DORQ_FIFO_OVFL_ERR)) { |
| @@ -477,11 +503,6 @@ static int qed_dorq_attn_cb(struct qed_hwfn *p_hwfn) · 20 unmodified lines | ||
| 477 | 503 | GET_FIELD(details, QED_DORQ_ATTENTION_SIZE) * 4, |
| 478 | 504 | first_drop_reason, all_drops_reason); |
| 479 | 505 | |
| 480 | − rc = qed_db_rec_handler(p_hwfn, p_ptt); | |
| 481 | − qed_periodic_db_rec_start(p_hwfn); | |
| 482 | − if (rc) | |
| 483 | − return rc; | |
| 484 | − | |
| 485 | 506 | /* Clear the doorbell drop details and prepare for next drop */ |
| 486 | 507 | qed_wr(p_hwfn, p_ptt, DORQ_REG_DB_DROP_DETAILS_REL, 0); |
| 487 | 508 | |
| @@ -507,6 +528,25 @@ static int qed_dorq_attn_cb(struct qed_hwfn *p_hwfn) · 19 unmodified lines | ||
| 507 | 528 | return -EINVAL; |
| 508 | 529 | } |
| 509 | 530 | |
| 531 | +static int qed_dorq_attn_cb(struct qed_hwfn *p_hwfn) | |
| 532 | +{ | |
| 533 | + p_hwfn->db_recovery_info.dorq_attn = true; | |
| 534 | + qed_dorq_attn_overflow(p_hwfn); | |
| 535 | + | |
| 536 | + return qed_dorq_attn_int_sts(p_hwfn); | |
| 537 | +} | |
| 538 | + | |
| 539 | +static void qed_dorq_attn_handler(struct qed_hwfn *p_hwfn) | |
| 540 | +{ | |
| 541 | + if (p_hwfn->db_recovery_info.dorq_attn) | |
| 542 | + goto out; | |
| 543 | + | |
| 544 | + /* Call DORQ callback if the attention was missed */ | |
| 545 | + qed_dorq_attn_cb(p_hwfn); | |
| 546 | +out: | |
| 547 | + p_hwfn->db_recovery_info.dorq_attn = false; | |
| 548 | +} | |
| 549 | + | |
| 510 | 550 | /* Instead of major changes to the data-structure, we have a some 'special' |
| 511 | 551 | * identifiers for sources that changed meaning between adapters. |
| 512 | 552 | */ |
| @@ -1080,6 +1120,9 @@ static int qed_int_deassertion(struct qed_hwfn *p_hwfn, · 567 unmodified lines | ||
| 1080 | 1120 | } |
| 1081 | 1121 | } |
| 1082 | 1122 | |
| 1123 | + /* Handle missed DORQ attention */ | |
| 1124 | + qed_dorq_attn_handler(p_hwfn); | |
| 1125 | + | |
| 1083 | 1126 | /* Clear IGU indication for the deasserted bits */ |
| 1084 | 1127 | DIRECT_REG_WR((u8 __iomem *)p_hwfn->regview + |
| 1085 | 1128 | GTT_BAR0_MAP_REG_IGU_CMD + |
| @@ -192,8 +192,8 @@ void qed_int_disable_post_isr_release(struct qed_dev *cdev); · 191 unmodified lines | ||
| 192 | 192 | |
| 193 | 193 | /** |
| 194 | 194 | * @brief - Doorbell Recovery handler. |
| 195 | − * Run DB_REAL_DEAL doorbell recovery in case of PF overflow | |
| 196 | − * (and flush DORQ if needed), otherwise run DB_REC_ONCE. | |
| 195 | + * Run doorbell recovery in case of PF overflow (and flush DORQ if | |
| 196 | + * needed). | |
| 197 | 197 | * |
| 198 | 198 | * @param p_hwfn |
| 199 | 199 | * @param p_ptt |
| @@ -970,7 +970,7 @@ static void qed_update_pf_params(struct qed_dev *cdev, · 969 unmodified lines | ||
| 970 | 970 | } |
| 971 | 971 | } |
| 972 | 972 | |
| 973 | −#define QED_PERIODIC_DB_REC_COUNT 100 | |
| 973 | +#define QED_PERIODIC_DB_REC_COUNT 10 | |
| 974 | 974 | #define QED_PERIODIC_DB_REC_INTERVAL_MS 100 |
| 975 | 975 | #define QED_PERIODIC_DB_REC_INTERVAL \ |
| 976 | 976 | msecs_to_jiffies(QED_PERIODIC_DB_REC_INTERVAL_MS) |
| @@ -1591,7 +1591,7 @@ static void qed_iov_vf_mbx_acquire(struct qed_hwfn *p_hwfn, · 1590 unmodified lines | ||
| 1591 | 1591 | p_vfdev->eth_fp_hsi_minor = ETH_HSI_VER_NO_PKT_LEN_TUNN; |
| 1592 | 1592 | } else { |
| 1593 | 1593 | DP_INFO(p_hwfn, |
| 1594 | − "VF[%d] needs fastpath HSI %02x.%02x, which is incompatible with loaded FW's faspath HSI %02x.%02x\n", | |
| 1594 | + "VF[%d] needs fastpath HSI %02x.%02x, which is incompatible with loaded FW's fastpath HSI %02x.%02x\n", | |
| 1595 | 1595 | vf->abs_vf_id, |
| 1596 | 1596 | req->vfdev_info.eth_fp_hsi_major, |
| 1597 | 1597 | req->vfdev_info.eth_fp_hsi_minor, |
| @@ -490,18 +490,17 @@ int qede_ptp_enable(struct qede_dev *edev, bool init_tc) · 489 unmodified lines | ||
| 490 | 490 | |
| 491 | 491 | ptp->clock = ptp_clock_register(&ptp->clock_info, &edev->pdev->dev); |
| 492 | 492 | if (IS_ERR(ptp->clock)) { |
| 493 | − rc = -EINVAL; | |
| 494 | 493 | DP_ERR(edev, "PTP clock registration failed\n"); |
| 494 | + qede_ptp_disable(edev); | |
| 495 | + rc = -EINVAL; | |
| 495 | 496 | goto err2; |
| 496 | 497 | } |
| 497 | 498 | |
| 498 | 499 | return 0; |
| 499 | 500 | |
| 500 | −err2: | |
| 501 | − qede_ptp_disable(edev); | |
| 502 | − ptp->clock = NULL; | |
| 503 | 501 | err1: |
| 504 | 502 | kfree(ptp); |
| 503 | +err2: | |
| 505 | 504 | edev->ptp = NULL; |
| 506 | 505 | |
| 507 | 506 | return rc; |
| @@ -1244,6 +1244,23 @@ static int team_port_add(struct team *team, struct net_device *port_dev, · 1243 unmodified lines | ||
| 1244 | 1244 | goto err_option_port_add; |
| 1245 | 1245 | } |
| 1246 | 1246 | |
| 1247 | + /* set promiscuity level to new slave */ | |
| 1248 | + if (dev->flags & IFF_PROMISC) { | |
| 1249 | + err = dev_set_promiscuity(port_dev, 1); | |
| 1250 | + if (err) | |
| 1251 | + goto err_set_slave_promisc; | |
| 1252 | + } | |
| 1253 | + | |
| 1254 | + /* set allmulti level to new slave */ | |
| 1255 | + if (dev->flags & IFF_ALLMULTI) { | |
| 1256 | + err = dev_set_allmulti(port_dev, 1); | |
| 1257 | + if (err) { | |
| 1258 | + if (dev->flags & IFF_PROMISC) | |
| 1259 | + dev_set_promiscuity(port_dev, -1); | |
| 1260 | + goto err_set_slave_promisc; | |
| 1261 | + } | |
| 1262 | + } | |
| 1263 | + | |
| 1247 | 1264 | netif_addr_lock_bh(dev); |
| 1248 | 1265 | dev_uc_sync_multiple(port_dev, dev); |
| 1249 | 1266 | dev_mc_sync_multiple(port_dev, dev); |
| @@ -1260,6 +1277,9 @@ static int team_port_add(struct team *team, struct net_device *port_dev, · 10 unmodified lines | ||
| 1260 | 1277 | |
| 1261 | 1278 | return 0; |
| 1262 | 1279 | |
| 1280 | +err_set_slave_promisc: | |
| 1281 | + __team_option_inst_del_port(team, port); | |
| 1282 | + | |
| 1263 | 1283 | err_option_port_add: |
| 1264 | 1284 | team_upper_dev_unlink(team, port); |
| 1265 | 1285 | |
| @@ -1305,6 +1325,12 @@ static int team_port_del(struct team *team, struct net_device *port_dev) · 39 unmodified lines | ||
| 1305 | 1325 | |
| 1306 | 1326 | team_port_disable(team, port); |
| 1307 | 1327 | list_del_rcu(&port->list); |
| 1328 | + | |
| 1329 | + if (dev->flags & IFF_PROMISC) | |
| 1330 | + dev_set_promiscuity(port_dev, -1); | |
| 1331 | + if (dev->flags & IFF_ALLMULTI) | |
| 1332 | + dev_set_allmulti(port_dev, -1); | |
| 1333 | + | |
| 1308 | 1334 | team_upper_dev_unlink(team, port); |
| 1309 | 1335 | netdev_rx_handler_unregister(port_dev); |
| 1310 | 1336 | team_port_disable_netpoll(port); |
| @@ -2728,7 +2728,7 @@ static void ath10k_htt_rx_tx_fetch_ind(struct ath10k *ar, struct sk_buff *skb) · 2727 unmodified lines | ||
| 2728 | 2728 | num_msdus++; |
| 2729 | 2729 | num_bytes += ret; |
| 2730 | 2730 | } |
| 2731 | − ieee80211_return_txq(hw, txq); | |
| 2731 | + ieee80211_return_txq(hw, txq, false); | |
| 2732 | 2732 | ieee80211_txq_schedule_end(hw, txq->ac); |
| 2733 | 2733 | |
| 2734 | 2734 | record->num_msdus = cpu_to_le16(num_msdus); |
| @@ -4089,7 +4089,7 @@ static int ath10k_mac_schedule_txq(struct ieee80211_hw *hw, u32 ac) · 4088 unmodified lines | ||
| 4089 | 4089 | if (ret < 0) |
| 4090 | 4090 | break; |
| 4091 | 4091 | } |
| 4092 | − ieee80211_return_txq(hw, txq); | |
| 4092 | + ieee80211_return_txq(hw, txq, false); | |
| 4093 | 4093 | ath10k_htt_tx_txq_update(hw, txq); |
| 4094 | 4094 | if (ret == -EBUSY) |
| 4095 | 4095 | break; |
| @@ -4374,7 +4374,7 @@ static void ath10k_mac_op_wake_tx_queue(struct ieee80211_hw *hw, · 278 unmodified lines | ||
| 4374 | 4374 | if (ret < 0) |
| 4375 | 4375 | break; |
| 4376 | 4376 | } |
| 4377 | − ieee80211_return_txq(hw, txq); | |
| 4377 | + ieee80211_return_txq(hw, txq, false); | |
| 4378 | 4378 | ath10k_htt_tx_txq_update(hw, txq); |
| 4379 | 4379 | out: |
| 4380 | 4380 | ieee80211_txq_schedule_end(hw, ac); |
| @@ -1938,12 +1938,15 @@ void ath_txq_schedule(struct ath_softc *sc, struct ath_txq *txq) · 1937 unmodified lines | ||
| 1938 | 1938 | goto out; |
| 1939 | 1939 | |
| 1940 | 1940 | while ((queue = ieee80211_next_txq(hw, txq->mac80211_qnum))) { |
| 1941 | + bool force; | |
| 1942 | + | |
| 1941 | 1943 | tid = (struct ath_atx_tid *)queue->drv_priv; |
| 1942 | 1944 | |
| 1943 | 1945 | ret = ath_tx_sched_aggr(sc, txq, tid); |
| 1944 | 1946 | ath_dbg(common, QUEUE, "ath_tx_sched_aggr returned %d\n", ret); |
| 1945 | 1947 | |
| 1946 | − ieee80211_return_txq(hw, queue); | |
| 1948 | + force = !skb_queue_empty(&tid->retry_q); | |
| 1949 | + ieee80211_return_txq(hw, queue, force); | |
| 1947 | 1950 | } |
| 1948 | 1951 | |
| 1949 | 1952 | out: |
| @@ -82,6 +82,7 @@ · 81 unmodified lines | ||
| 82 | 82 | #define IWL_22000_HR_A0_FW_PRE "iwlwifi-QuQnj-a0-hr-a0-" |
| 83 | 83 | #define IWL_22000_SU_Z0_FW_PRE "iwlwifi-su-z0-" |
| 84 | 84 | #define IWL_QU_B_JF_B_FW_PRE "iwlwifi-Qu-b0-jf-b0-" |
| 85 | +#define IWL_QUZ_A_HR_B_FW_PRE "iwlwifi-QuZ-a0-hr-b0-" | |
| 85 | 86 | #define IWL_QNJ_B_JF_B_FW_PRE "iwlwifi-QuQnj-b0-jf-b0-" |
| 86 | 87 | #define IWL_CC_A_FW_PRE "iwlwifi-cc-a0-" |
| 87 | 88 | #define IWL_22000_SO_A_JF_B_FW_PRE "iwlwifi-so-a0-jf-b0-" |
| @@ -105,8 +106,8 @@ · 17 unmodified lines | ||
| 105 | 106 | IWL_22000_HR_A0_FW_PRE __stringify(api) ".ucode" |
| 106 | 107 | #define IWL_22000_SU_Z0_MODULE_FIRMWARE(api) \ |
| 107 | 108 | IWL_22000_SU_Z0_FW_PRE __stringify(api) ".ucode" |
| 108 | −#define IWL_QU_B_JF_B_MODULE_FIRMWARE(api) \ | |
| 109 | − IWL_QU_B_JF_B_FW_PRE __stringify(api) ".ucode" | |
| 109 | +#define IWL_QUZ_A_HR_B_MODULE_FIRMWARE(api) \ | |
| 110 | + IWL_QUZ_A_HR_B_FW_PRE __stringify(api) ".ucode" | |
| 110 | 111 | #define IWL_QU_B_JF_B_MODULE_FIRMWARE(api) \ |
| 111 | 112 | IWL_QU_B_JF_B_FW_PRE __stringify(api) ".ucode" |
| 112 | 113 | #define IWL_QNJ_B_JF_B_MODULE_FIRMWARE(api) \ |
| @@ -235,8 +236,20 @@ const struct iwl_cfg iwl_ax101_cfg_qu_hr = { · 122 unmodified lines | ||
| 235 | 236 | .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, |
| 236 | 237 | }; |
| 237 | 238 | |
| 238 | −const struct iwl_cfg iwl22260_2ax_cfg = { | |
| 239 | − .name = "Intel(R) Wireless-AX 22260", | |
| 239 | +const struct iwl_cfg iwl_ax101_cfg_quz_hr = { | |
| 240 | + .name = "Intel(R) Wi-Fi 6 AX101", | |
| 241 | + .fw_name_pre = IWL_QUZ_A_HR_B_FW_PRE, | |
| 242 | + IWL_DEVICE_22500, | |
| 243 | + /* | |
| 244 | + * This device doesn't support receiving BlockAck with a large bitmap | |
| 245 | + * so we need to restrict the size of transmitted aggregation to the | |
| 246 | + * HT size; mac80211 would otherwise pick the HE max (256) by default. | |
| 247 | + */ | |
| 248 | + .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, | |
| 249 | +}; | |
| 250 | + | |
| 251 | +const struct iwl_cfg iwl_ax200_cfg_cc = { | |
| 252 | + .name = "Intel(R) Wi-Fi 6 AX200 160MHz", | |
| 240 | 253 | .fw_name_pre = IWL_CC_A_FW_PRE, |
| 241 | 254 | IWL_DEVICE_22500, |
| 242 | 255 | /* |
| @@ -249,7 +262,7 @@ const struct iwl_cfg iwl22260_2ax_cfg = { · 6 unmodified lines | ||
| 249 | 262 | }; |
| 250 | 263 | |
| 251 | 264 | const struct iwl_cfg killer1650x_2ax_cfg = { |
| 252 | − .name = "Killer(R) Wireless-AX 1650x Wireless Network Adapter (200NGW)", | |
| 265 | + .name = "Killer(R) Wi-Fi 6 AX1650x 160MHz Wireless Network Adapter (200NGW)", | |
| 253 | 266 | .fw_name_pre = IWL_CC_A_FW_PRE, |
| 254 | 267 | IWL_DEVICE_22500, |
| 255 | 268 | /* |
| @@ -262,7 +275,7 @@ const struct iwl_cfg killer1650x_2ax_cfg = { · 6 unmodified lines | ||
| 262 | 275 | }; |
| 263 | 276 | |
| 264 | 277 | const struct iwl_cfg killer1650w_2ax_cfg = { |
| 265 | − .name = "Killer(R) Wireless-AX 1650w Wireless Network Adapter (200D2W)", | |
| 278 | + .name = "Killer(R) Wi-Fi 6 AX1650w 160MHz Wireless Network Adapter (200D2W)", | |
| 266 | 279 | .fw_name_pre = IWL_CC_A_FW_PRE, |
| 267 | 280 | IWL_DEVICE_22500, |
| 268 | 281 | /* |
| @@ -328,7 +341,7 @@ const struct iwl_cfg killer1550s_2ac_cfg_qu_b0_jf_b0 = { · 59 unmodified lines | ||
| 328 | 341 | }; |
| 329 | 342 | |
| 330 | 343 | const struct iwl_cfg killer1650s_2ax_cfg_qu_b0_hr_b0 = { |
| 331 | − .name = "Killer(R) Wireless-AX 1650i Wireless Network Adapter (22560NGW)", | |
| 344 | + .name = "Killer(R) Wi-Fi 6 AX1650i 160MHz Wireless Network Adapter (201NGW)", | |
| 332 | 345 | .fw_name_pre = IWL_22000_QU_B_HR_B_FW_PRE, |
| 333 | 346 | IWL_DEVICE_22500, |
| 334 | 347 | /* |
| @@ -340,7 +353,7 @@ const struct iwl_cfg killer1650s_2ax_cfg_qu_b0_hr_b0 = { · 5 unmodified lines | ||
| 340 | 353 | }; |
| 341 | 354 | |
| 342 | 355 | const struct iwl_cfg killer1650i_2ax_cfg_qu_b0_hr_b0 = { |
| 343 | − .name = "Killer(R) Wireless-AX 1650s Wireless Network Adapter (22560D2W)", | |
| 356 | + .name = "Killer(R) Wi-Fi 6 AX1650s 160MHz Wireless Network Adapter (201D2W)", | |
| 344 | 357 | .fw_name_pre = IWL_22000_QU_B_HR_B_FW_PRE, |
| 345 | 358 | IWL_DEVICE_22500, |
| 346 | 359 | /* |
| @@ -444,6 +457,7 @@ MODULE_FIRMWARE(IWL_22000_HR_B_QNJ_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); · 97 unmodified lines | ||
| 444 | 457 | MODULE_FIRMWARE(IWL_22000_HR_A0_QNJ_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); |
| 445 | 458 | MODULE_FIRMWARE(IWL_22000_SU_Z0_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); |
| 446 | 459 | MODULE_FIRMWARE(IWL_QU_B_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); |
| 460 | +MODULE_FIRMWARE(IWL_QUZ_A_HR_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); | |
| 447 | 461 | MODULE_FIRMWARE(IWL_QNJ_B_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); |
| 448 | 462 | MODULE_FIRMWARE(IWL_CC_A_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); |
| 449 | 463 | MODULE_FIRMWARE(IWL_22000_SO_A_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); |
| @@ -1614,6 +1614,7 @@ iwl_dump_ini_mem(struct iwl_fw_runtime *fwrt, · 1613 unmodified lines | ||
| 1614 | 1614 | if (!range) { |
| 1615 | 1615 | IWL_ERR(fwrt, "Failed to fill region header: id=%d, type=%d\n", |
| 1616 | 1616 | le32_to_cpu(reg->region_id), type); |
| 1617 | + memset(*data, 0, le32_to_cpu((*data)->len)); | |
| 1617 | 1618 | return; |
| 1618 | 1619 | } |
| 1619 | 1620 | |
| @@ -1623,6 +1624,7 @@ iwl_dump_ini_mem(struct iwl_fw_runtime *fwrt, · 3 unmodified lines | ||
| 1623 | 1624 | if (range_size < 0) { |
| 1624 | 1625 | IWL_ERR(fwrt, "Failed to dump region: id=%d, type=%d\n", |
| 1625 | 1626 | le32_to_cpu(reg->region_id), type); |
| 1627 | + memset(*data, 0, le32_to_cpu((*data)->len)); | |
| 1626 | 1628 | return; |
| 1627 | 1629 | } |
| 1628 | 1630 | range = range + range_size; |
| @@ -1807,12 +1809,12 @@ _iwl_fw_error_ini_dump(struct iwl_fw_runtime *fwrt, · 178 unmodified lines | ||
| 1807 | 1809 | |
| 1808 | 1810 | trigger = fwrt->dump.active_trigs[id].trig; |
| 1809 | 1811 | |
| 1810 | − size = sizeof(*dump_file); | |
| 1811 | − size += iwl_fw_ini_get_trigger_len(fwrt, trigger); | |
| 1812 | − | |
| 1812 | + size = iwl_fw_ini_get_trigger_len(fwrt, trigger); | |
| 1813 | 1813 | if (!size) |
| 1814 | 1814 | return NULL; |
| 1815 | 1815 | |
| 1816 | + size += sizeof(*dump_file); | |
| 1817 | + | |
| 1816 | 1818 | dump_file = vzalloc(size); |
| 1817 | 1819 | if (!dump_file) |
| 1818 | 1820 | return NULL; |
| @@ -1942,14 +1944,10 @@ int iwl_fw_dbg_error_collect(struct iwl_fw_runtime *fwrt, · 123 unmodified lines | ||
| 1942 | 1944 | iwl_dump_error_desc->len = 0; |
| 1943 | 1945 | |
| 1944 | 1946 | ret = iwl_fw_dbg_collect_desc(fwrt, iwl_dump_error_desc, false, 0); |
| 1945 | − if (ret) { | |
| 1947 | + if (ret) | |
| 1946 | 1948 | kfree(iwl_dump_error_desc); |
| 1947 | − } else { | |
| 1948 | − set_bit(STATUS_FW_WAIT_DUMP, &fwrt->trans->status); | |
| 1949 | − | |
| 1950 | − /* trigger nmi to halt the fw */ | |
| 1951 | − iwl_force_nmi(fwrt->trans); | |
| 1952 | − } | |
| 1949 | + else | |
| 1950 | + iwl_trans_sync_nmi(fwrt->trans); | |
| 1953 | 1951 | |
| 1954 | 1952 | return ret; |
| 1955 | 1953 | } |
| @@ -2489,22 +2487,6 @@ IWL_EXPORT_SYMBOL(iwl_fw_dbg_apply_point); · 533 unmodified lines | ||
| 2489 | 2487 | |
| 2490 | 2488 | void iwl_fwrt_stop_device(struct iwl_fw_runtime *fwrt) |
| 2491 | 2489 | { |
| 2492 | − /* if the wait event timeout elapses instead of wake up then | |
| 2493 | − * the driver did not receive NMI interrupt and can not assume the FW | |
| 2494 | − * is halted | |
| 2495 | − */ | |
| 2496 | − int ret = wait_event_timeout(fwrt->trans->fw_halt_waitq, | |
| 2497 | − !test_bit(STATUS_FW_WAIT_DUMP, | |
| 2498 | − &fwrt->trans->status), | |
| 2499 | − msecs_to_jiffies(2000)); | |
| 2500 | − if (!ret) { | |
| 2501 | − /* failed to receive NMI interrupt, assuming the FW is stuck */ | |
| 2502 | − set_bit(STATUS_FW_ERROR, &fwrt->trans->status); | |
| 2503 | − | |
| 2504 | − clear_bit(STATUS_FW_WAIT_DUMP, &fwrt->trans->status); | |
| 2505 | − } | |
| 2506 | − | |
| 2507 | − /* Assuming the op mode mutex is held at this point */ | |
| 2508 | 2490 | iwl_fw_dbg_collect_sync(fwrt); |
| 2509 | 2491 | |
| 2510 | 2492 | iwl_trans_stop_device(fwrt->trans); |
| @@ -76,7 +76,6 @@ void iwl_fw_runtime_init(struct iwl_fw_runtime *fwrt, struct iwl_trans *trans, · 75 unmodified lines | ||
| 76 | 76 | fwrt->ops_ctx = ops_ctx; |
| 77 | 77 | INIT_DELAYED_WORK(&fwrt->dump.wk, iwl_fw_error_dump_wk); |
| 78 | 78 | iwl_fwrt_dbgfs_register(fwrt, dbgfs_dir); |
| 79 | − init_waitqueue_head(&fwrt->trans->fw_halt_waitq); | |
| 80 | 79 | } |
| 81 | 80 | IWL_EXPORT_SYMBOL(iwl_fw_runtime_init); |
| 82 | 81 | |
| @@ -549,8 +549,9 @@ extern const struct iwl_cfg iwl22000_2ac_cfg_hr; · 548 unmodified lines | ||
| 549 | 549 | extern const struct iwl_cfg iwl22000_2ac_cfg_hr_cdb; |
| 550 | 550 | extern const struct iwl_cfg iwl22000_2ac_cfg_jf; |
| 551 | 551 | extern const struct iwl_cfg iwl_ax101_cfg_qu_hr; |
| 552 | +extern const struct iwl_cfg iwl_ax101_cfg_quz_hr; | |
| 552 | 553 | extern const struct iwl_cfg iwl22000_2ax_cfg_hr; |
| 553 | −extern const struct iwl_cfg iwl22260_2ax_cfg; | |
| 554 | +extern const struct iwl_cfg iwl_ax200_cfg_cc; | |
| 554 | 555 | extern const struct iwl_cfg killer1650s_2ax_cfg_qu_b0_hr_b0; |
| 555 | 556 | extern const struct iwl_cfg killer1650i_2ax_cfg_qu_b0_hr_b0; |
| 556 | 557 | extern const struct iwl_cfg killer1650x_2ax_cfg; |
| @@ -327,6 +327,7 @@ enum { · 326 unmodified lines | ||
| 327 | 327 | #define CSR_HW_REV_TYPE_NONE (0x00001F0) |
| 328 | 328 | #define CSR_HW_REV_TYPE_QNJ (0x0000360) |
| 329 | 329 | #define CSR_HW_REV_TYPE_QNJ_B0 (0x0000364) |
| 330 | +#define CSR_HW_REV_TYPE_QUZ (0x0000354) | |
| 330 | 331 | #define CSR_HW_REV_TYPE_HR_CDB (0x0000340) |
| 331 | 332 | #define CSR_HW_REV_TYPE_SO (0x0000370) |
| 332 | 333 | #define CSR_HW_REV_TYPE_TY (0x0000420) |
| @@ -338,7 +338,6 @@ enum iwl_d3_status { · 337 unmodified lines | ||
| 338 | 338 | * are sent |
| 339 | 339 | * @STATUS_TRANS_IDLE: the trans is idle - general commands are not to be sent |
| 340 | 340 | * @STATUS_TRANS_DEAD: trans is dead - avoid any read/write operation |
| 341 | − * @STATUS_FW_WAIT_DUMP: if set, wait until cleared before collecting dump | |
| 342 | 341 | */ |
| 343 | 342 | enum iwl_trans_status { |
| 344 | 343 | STATUS_SYNC_HCMD_ACTIVE, |
| @@ -351,7 +350,6 @@ enum iwl_trans_status { · 6 unmodified lines | ||
| 351 | 350 | STATUS_TRANS_GOING_IDLE, |
| 352 | 351 | STATUS_TRANS_IDLE, |
| 353 | 352 | STATUS_TRANS_DEAD, |
| 354 | − STATUS_FW_WAIT_DUMP, | |
| 355 | 353 | }; |
| 356 | 354 | |
| 357 | 355 | static inline int |
| @@ -618,6 +616,7 @@ struct iwl_trans_ops { · 260 unmodified lines | ||
| 618 | 616 | struct iwl_trans_dump_data *(*dump_data)(struct iwl_trans *trans, |
| 619 | 617 | u32 dump_mask); |
| 620 | 618 | void (*debugfs_cleanup)(struct iwl_trans *trans); |
| 619 | + void (*sync_nmi)(struct iwl_trans *trans); | |
| 621 | 620 | }; |
| 622 | 621 | |
| 623 | 622 | /** |
| @@ -831,7 +830,6 @@ struct iwl_trans { · 207 unmodified lines | ||
| 831 | 830 | u32 lmac_error_event_table[2]; |
| 832 | 831 | u32 umac_error_event_table; |
| 833 | 832 | unsigned int error_event_table_tlv_status; |
| 834 | − wait_queue_head_t fw_halt_waitq; | |
| 835 | 833 | |
| 836 | 834 | /* pointer to trans specific struct */ |
| 837 | 835 | /*Ensure that this pointer will always be aligned to sizeof pointer */ |
| @@ -1239,10 +1237,12 @@ static inline void iwl_trans_fw_error(struct iwl_trans *trans) · 401 unmodified lines | ||
| 1239 | 1237 | /* prevent double restarts due to the same erroneous FW */ |
| 1240 | 1238 | if (!test_and_set_bit(STATUS_FW_ERROR, &trans->status)) |
| 1241 | 1239 | iwl_op_mode_nic_error(trans->op_mode); |
| 1240 | +} | |
| 1242 | 1241 | |
| 1243 | − if (test_and_clear_bit(STATUS_FW_WAIT_DUMP, &trans->status)) | |
| 1244 | − wake_up(&trans->fw_halt_waitq); | |
| 1245 | − | |
| 1242 | +static inline void iwl_trans_sync_nmi(struct iwl_trans *trans) | |
| 1243 | +{ | |
| 1244 | + if (trans->ops->sync_nmi) | |
| 1245 | + trans->ops->sync_nmi(trans); | |
| 1246 | 1246 | } |
| 1247 | 1247 | |
| 1248 | 1248 | /***************************************************** |
| @@ -2714,9 +2714,6 @@ static void iwl_mvm_stop_ap_ibss(struct ieee80211_hw *hw, · 2713 unmodified lines | ||
| 2714 | 2714 | |
| 2715 | 2715 | iwl_mvm_mac_ctxt_remove(mvm, vif); |
| 2716 | 2716 | |
| 2717 | − kfree(mvmvif->ap_wep_key); | |
| 2718 | − mvmvif->ap_wep_key = NULL; | |
| 2719 | − | |
| 2720 | 2717 | mutex_unlock(&mvm->mutex); |
| 2721 | 2718 | } |
| 2722 | 2719 | |
| @@ -3183,24 +3180,7 @@ static int iwl_mvm_mac_sta_state(struct ieee80211_hw *hw, · 460 unmodified lines | ||
| 3183 | 3180 | ret = iwl_mvm_update_sta(mvm, vif, sta); |
| 3184 | 3181 | } else if (old_state == IEEE80211_STA_ASSOC && |
| 3185 | 3182 | new_state == IEEE80211_STA_AUTHORIZED) { |
| 3186 | − /* if wep is used, need to set the key for the station now */ | |
| 3187 | − if (vif->type == NL80211_IFTYPE_AP && mvmvif->ap_wep_key) { | |
| 3188 | − mvm_sta->wep_key = | |
| 3189 | − kmemdup(mvmvif->ap_wep_key, | |
| 3190 | − sizeof(*mvmvif->ap_wep_key) + | |
| 3191 | − mvmvif->ap_wep_key->keylen, | |
| 3192 | − GFP_KERNEL); | |
| 3193 | − if (!mvm_sta->wep_key) { | |
| 3194 | − ret = -ENOMEM; | |
| 3195 | − goto out_unlock; | |
| 3196 | − } | |
| 3197 | − | |
| 3198 | − ret = iwl_mvm_set_sta_key(mvm, vif, sta, | |
| 3199 | − mvm_sta->wep_key, | |
| 3200 | − STA_KEY_IDX_INVALID); | |
| 3201 | − } else { | |
| 3202 | − ret = 0; | |
| 3203 | − } | |
| 3183 | + ret = 0; | |
| 3204 | 3184 | |
| 3205 | 3185 | /* we don't support TDLS during DCM */ |
| 3206 | 3186 | if (iwl_mvm_phy_ctx_count(mvm) > 1) |
| @@ -3242,17 +3222,6 @@ static int iwl_mvm_mac_sta_state(struct ieee80211_hw *hw, · 35 unmodified lines | ||
| 3242 | 3222 | NL80211_TDLS_DISABLE_LINK); |
| 3243 | 3223 | } |
| 3244 | 3224 | |
| 3245 | − /* Remove STA key if this is an AP using WEP */ | |
| 3246 | − if (vif->type == NL80211_IFTYPE_AP && mvmvif->ap_wep_key) { | |
| 3247 | − int rm_ret = iwl_mvm_remove_sta_key(mvm, vif, sta, | |
| 3248 | − mvm_sta->wep_key); | |
| 3249 | − | |
| 3250 | − if (!ret) | |
| 3251 | − ret = rm_ret; | |
| 3252 | − kfree(mvm_sta->wep_key); | |
| 3253 | − mvm_sta->wep_key = NULL; | |
| 3254 | − } | |
| 3255 | − | |
| 3256 | 3225 | if (unlikely(ret && |
| 3257 | 3226 | test_bit(IWL_MVM_STATUS_HW_RESTART_REQUESTED, |
| 3258 | 3227 | &mvm->status))) |
| @@ -3289,6 +3258,13 @@ static void iwl_mvm_sta_rc_update(struct ieee80211_hw *hw, · 30 unmodified lines | ||
| 3289 | 3258 | struct ieee80211_sta *sta, u32 changed) |
| 3290 | 3259 | { |
| 3291 | 3260 | struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw); |
| 3261 | + struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); | |
| 3262 | + | |
| 3263 | + if (changed & (IEEE80211_RC_BW_CHANGED | | |
| 3264 | + IEEE80211_RC_SUPP_RATES_CHANGED | | |
| 3265 | + IEEE80211_RC_NSS_CHANGED)) | |
| 3266 | + iwl_mvm_rs_rate_init(mvm, sta, mvmvif->phy_ctxt->channel->band, | |
| 3267 | + true); | |
| 3292 | 3268 | |
| 3293 | 3269 | if (vif->type == NL80211_IFTYPE_STATION && |
| 3294 | 3270 | changed & IEEE80211_RC_NSS_CHANGED) |
| @@ -3439,20 +3415,12 @@ static int iwl_mvm_mac_set_key(struct ieee80211_hw *hw, · 144 unmodified lines | ||
| 3439 | 3415 | break; |
| 3440 | 3416 | case WLAN_CIPHER_SUITE_WEP40: |
| 3441 | 3417 | case WLAN_CIPHER_SUITE_WEP104: |
| 3442 | − if (vif->type == NL80211_IFTYPE_AP) { | |
| 3443 | − struct iwl_mvm_vif *mvmvif = | |
| 3444 | − iwl_mvm_vif_from_mac80211(vif); | |
| 3445 | − | |
| 3446 | − mvmvif->ap_wep_key = kmemdup(key, | |
| 3447 | − sizeof(*key) + key->keylen, | |
| 3448 | − GFP_KERNEL); | |
| 3449 | − if (!mvmvif->ap_wep_key) | |
| 3450 | − return -ENOMEM; | |
| 3451 | − } | |
| 3452 | − | |
| 3453 | − if (vif->type != NL80211_IFTYPE_STATION) | |
| 3454 | − return 0; | |
| 3455 | − break; | |
| 3418 | + if (vif->type == NL80211_IFTYPE_STATION) | |
| 3419 | + break; | |
| 3420 | + if (iwl_mvm_has_new_tx_api(mvm)) | |
| 3421 | + return -EOPNOTSUPP; | |
| 3422 | + /* support HW crypto on TX */ | |
| 3423 | + return 0; | |
| 3456 | 3424 | default: |
| 3457 | 3425 | /* currently FW supports only one optional cipher scheme */ |
| 3458 | 3426 | if (hw->n_cipher_schemes && |
| @@ -3540,12 +3508,17 @@ static int iwl_mvm_mac_set_key(struct ieee80211_hw *hw, · 81 unmodified lines | ||
| 3540 | 3508 | ret = iwl_mvm_set_sta_key(mvm, vif, sta, key, key_offset); |
| 3541 | 3509 | if (ret) { |
| 3542 | 3510 | IWL_WARN(mvm, "set key failed\n"); |
| 3511 | + key->hw_key_idx = STA_KEY_IDX_INVALID; | |
| 3543 | 3512 | /* |
| 3544 | 3513 | * can't add key for RX, but we don't need it |
| 3545 | − * in the device for TX so still return 0 | |
| 3514 | + * in the device for TX so still return 0, | |
| 3515 | + * unless we have new TX API where we cannot | |
| 3516 | + * put key material into the TX_CMD | |
| 3546 | 3517 | */ |
| 3547 | − key->hw_key_idx = STA_KEY_IDX_INVALID; | |
| 3548 | − ret = 0; | |
| 3518 | + if (iwl_mvm_has_new_tx_api(mvm)) | |
| 3519 | + ret = -EOPNOTSUPP; | |
| 3520 | + else | |
| 3521 | + ret = 0; | |
| 3549 | 3522 | } |
| 3550 | 3523 | |
| 3551 | 3524 | break; |
| @@ -498,7 +498,6 @@ struct iwl_mvm_vif { · 497 unmodified lines | ||
| 498 | 498 | netdev_features_t features; |
| 499 | 499 | |
| 500 | 500 | struct iwl_probe_resp_data __rcu *probe_resp_data; |
| 501 | − struct ieee80211_key_conf *ap_wep_key; | |
| 502 | 501 | }; |
| 503 | 502 | |
| 504 | 503 | static inline struct iwl_mvm_vif * |
| @@ -8,7 +8,7 @@ · 7 unmodified lines | ||
| 8 | 8 | * Copyright(c) 2012 - 2015 Intel Corporation. All rights reserved. |
| 9 | 9 | * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH |
| 10 | 10 | * Copyright(c) 2016 - 2017 Intel Deutschland GmbH |
| 11 | − * Copyright(c) 2018 Intel Corporation | |
| 11 | + * Copyright(c) 2018 - 2019 Intel Corporation | |
| 12 | 12 | * |
| 13 | 13 | * This program is free software; you can redistribute it and/or modify |
| 14 | 14 | * it under the terms of version 2 of the GNU General Public License as |
| @@ -31,7 +31,7 @@ · 16 unmodified lines | ||
| 31 | 31 | * Copyright(c) 2012 - 2015 Intel Corporation. All rights reserved. |
| 32 | 32 | * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH |
| 33 | 33 | * Copyright(c) 2016 - 2017 Intel Deutschland GmbH |
| 34 | − * Copyright(c) 2018 Intel Corporation | |
| 34 | + * Copyright(c) 2018 - 2019 Intel Corporation | |
| 35 | 35 | * All rights reserved. |
| 36 | 36 | * |
| 37 | 37 | * Redistribution and use in source and binary forms, with or without |
| @@ -1399,7 +1399,9 @@ void iwl_mvm_add_new_dqa_stream_wk(struct work_struct *wk) · 1361 unmodified lines | ||
| 1399 | 1399 | |
| 1400 | 1400 | iwl_mvm_sta_alloc_queue(mvm, txq->sta, txq->ac, tid); |
| 1401 | 1401 | list_del_init(&mvmtxq->list); |
| 1402 | + local_bh_disable(); | |
| 1402 | 1403 | iwl_mvm_mac_itxq_xmit(mvm->hw, txq); |
| 1404 | + local_bh_enable(); | |
| 1403 | 1405 | } |
| 1404 | 1406 | |
| 1405 | 1407 | mutex_unlock(&mvm->mutex); |
| @@ -2333,21 +2335,6 @@ int iwl_mvm_add_mcast_sta(struct iwl_mvm *mvm, struct ieee80211_vif *vif) · 927 unmodified lines | ||
| 2333 | 2335 | iwl_mvm_enable_txq(mvm, NULL, mvmvif->cab_queue, 0, &cfg, |
| 2334 | 2336 | timeout); |
| 2335 | 2337 | |
| 2336 | − if (mvmvif->ap_wep_key) { | |
| 2337 | − u8 key_offset = iwl_mvm_set_fw_key_idx(mvm); | |
| 2338 | − | |
| 2339 | − __set_bit(key_offset, mvm->fw_key_table); | |
| 2340 | − | |
| 2341 | − if (key_offset == STA_KEY_IDX_INVALID) | |
| 2342 | − return -ENOSPC; | |
| 2343 | − | |
| 2344 | − ret = iwl_mvm_send_sta_key(mvm, mvmvif->mcast_sta.sta_id, | |
| 2345 | − mvmvif->ap_wep_key, true, 0, NULL, 0, | |
| 2346 | − key_offset, 0); | |
| 2347 | − if (ret) | |
| 2348 | − return ret; | |
| 2349 | − } | |
| 2350 | − | |
| 2351 | 2338 | return 0; |
| 2352 | 2339 | } |
| 2353 | 2340 | |
| @@ -2419,28 +2406,6 @@ int iwl_mvm_rm_mcast_sta(struct iwl_mvm *mvm, struct ieee80211_vif *vif) · 65 unmodified lines | ||
| 2419 | 2406 | |
| 2420 | 2407 | iwl_mvm_disable_txq(mvm, NULL, mvmvif->cab_queue, 0, 0); |
| 2421 | 2408 | |
| 2422 | − if (mvmvif->ap_wep_key) { | |
| 2423 | − int i; | |
| 2424 | − | |
| 2425 | − if (!__test_and_clear_bit(mvmvif->ap_wep_key->hw_key_idx, | |
| 2426 | − mvm->fw_key_table)) { | |
| 2427 | − IWL_ERR(mvm, "offset %d not used in fw key table.\n", | |
| 2428 | − mvmvif->ap_wep_key->hw_key_idx); | |
| 2429 | − return -ENOENT; | |
| 2430 | − } | |
| 2431 | − | |
| 2432 | − /* track which key was deleted last */ | |
| 2433 | − for (i = 0; i < STA_KEY_MAX_NUM; i++) { | |
| 2434 | − if (mvm->fw_key_deleted[i] < U8_MAX) | |
| 2435 | − mvm->fw_key_deleted[i]++; | |
| 2436 | − } | |
| 2437 | − mvm->fw_key_deleted[mvmvif->ap_wep_key->hw_key_idx] = 0; | |
| 2438 | − ret = __iwl_mvm_remove_sta_key(mvm, mvmvif->mcast_sta.sta_id, | |
| 2439 | − mvmvif->ap_wep_key, true); | |
| 2440 | − if (ret) | |
| 2441 | − return ret; | |
| 2442 | − } | |
| 2443 | − | |
| 2444 | 2409 | ret = iwl_mvm_rm_sta_common(mvm, mvmvif->mcast_sta.sta_id); |
| 2445 | 2410 | if (ret) |
| 2446 | 2411 | IWL_WARN(mvm, "Failed sending remove station\n"); |
| @@ -8,7 +8,7 @@ · 7 unmodified lines | ||
| 8 | 8 | * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved. |
| 9 | 9 | * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH |
| 10 | 10 | * Copyright(c) 2015 - 2016 Intel Deutschland GmbH |
| 11 | − * Copyright(c) 2018 Intel Corporation | |
| 11 | + * Copyright(c) 2018 - 2019 Intel Corporation | |
| 12 | 12 | * |
| 13 | 13 | * This program is free software; you can redistribute it and/or modify |
| 14 | 14 | * it under the terms of version 2 of the GNU General Public License as |
| @@ -31,7 +31,7 @@ · 16 unmodified lines | ||
| 31 | 31 | * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved. |
| 32 | 32 | * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH |
| 33 | 33 | * Copyright(c) 2015 - 2016 Intel Deutschland GmbH |
| 34 | − * Copyright(c) 2018 Intel Corporation | |
| 34 | + * Copyright(c) 2018 - 2019 Intel Corporation | |
| 35 | 35 | * All rights reserved. |
| 36 | 36 | * |
| 37 | 37 | * Redistribution and use in source and binary forms, with or without |
| @@ -394,7 +394,6 @@ struct iwl_mvm_rxq_dup_data { · 356 unmodified lines | ||
| 394 | 394 | * the BA window. To be used for UAPSD only. |
| 395 | 395 | * @ptk_pn: per-queue PTK PN data structures |
| 396 | 396 | * @dup_data: per queue duplicate packet detection data |
| 397 | − * @wep_key: used in AP mode. Is a duplicate of the WEP key. | |
| 398 | 397 | * @deferred_traffic_tid_map: indication bitmap of deferred traffic per-TID |
| 399 | 398 | * @tx_ant: the index of the antenna to use for data tx to this station. Only |
| 400 | 399 | * used during connection establishment (e.g. for the 4 way handshake |
| @@ -426,8 +425,6 @@ struct iwl_mvm_sta { · 25 unmodified lines | ||
| 426 | 425 | struct iwl_mvm_key_pn __rcu *ptk_pn[4]; |
| 427 | 426 | struct iwl_mvm_rxq_dup_data *dup_data; |
| 428 | 427 | |
| 429 | − struct ieee80211_key_conf *wep_key; | |
| 430 | − | |
| 431 | 428 | u8 reserved_queue; |
| 432 | 429 | |
| 433 | 430 | /* Temporary, until the new TLC will control the Tx protection */ |
| @@ -953,14 +953,15 @@ static const struct pci_device_id iwl_hw_card_ids[] = { · 952 unmodified lines | ||
| 953 | 953 | {IWL_PCI_DEVICE(0xA0F0, 0x1652, killer1650i_2ax_cfg_qu_b0_hr_b0)}, |
| 954 | 954 | {IWL_PCI_DEVICE(0xA0F0, 0x4070, iwl_ax101_cfg_qu_hr)}, |
| 955 | 955 | |
| 956 | − {IWL_PCI_DEVICE(0x2723, 0x0080, iwl22260_2ax_cfg)}, | |
| 957 | − {IWL_PCI_DEVICE(0x2723, 0x0084, iwl22260_2ax_cfg)}, | |
| 958 | − {IWL_PCI_DEVICE(0x2723, 0x0088, iwl22260_2ax_cfg)}, | |
| 959 | − {IWL_PCI_DEVICE(0x2723, 0x008C, iwl22260_2ax_cfg)}, | |
| 956 | + {IWL_PCI_DEVICE(0x2723, 0x0080, iwl_ax200_cfg_cc)}, | |
| 957 | + {IWL_PCI_DEVICE(0x2723, 0x0084, iwl_ax200_cfg_cc)}, | |
| 958 | + {IWL_PCI_DEVICE(0x2723, 0x0088, iwl_ax200_cfg_cc)}, | |
| 959 | + {IWL_PCI_DEVICE(0x2723, 0x008C, iwl_ax200_cfg_cc)}, | |
| 960 | 960 | {IWL_PCI_DEVICE(0x2723, 0x1653, killer1650w_2ax_cfg)}, |
| 961 | 961 | {IWL_PCI_DEVICE(0x2723, 0x1654, killer1650x_2ax_cfg)}, |
| 962 | − {IWL_PCI_DEVICE(0x2723, 0x4080, iwl22260_2ax_cfg)}, | |
| 963 | − {IWL_PCI_DEVICE(0x2723, 0x4088, iwl22260_2ax_cfg)}, | |
| 962 | + {IWL_PCI_DEVICE(0x2723, 0x2080, iwl_ax200_cfg_cc)}, | |
| 963 | + {IWL_PCI_DEVICE(0x2723, 0x4080, iwl_ax200_cfg_cc)}, | |
| 964 | + {IWL_PCI_DEVICE(0x2723, 0x4088, iwl_ax200_cfg_cc)}, | |
| 964 | 965 | |
| 965 | 966 | {IWL_PCI_DEVICE(0x1a56, 0x1653, killer1650w_2ax_cfg)}, |
| 966 | 967 | {IWL_PCI_DEVICE(0x1a56, 0x1654, killer1650x_2ax_cfg)}, |
| @@ -1043,7 +1043,7 @@ static inline bool iwl_pcie_dbg_on(struct iwl_trans *trans) · 1042 unmodified lines | ||
| 1043 | 1043 | |
| 1044 | 1044 | void iwl_trans_pcie_rf_kill(struct iwl_trans *trans, bool state); |
| 1045 | 1045 | void iwl_trans_pcie_dump_regs(struct iwl_trans *trans); |
| 1046 | −void iwl_trans_sync_nmi(struct iwl_trans *trans); | |
| 1046 | +void iwl_trans_pcie_sync_nmi(struct iwl_trans *trans); | |
| 1047 | 1047 | |
| 1048 | 1048 | #ifdef CONFIG_IWLWIFI_DEBUGFS |
| 1049 | 1049 | int iwl_trans_pcie_dbgfs_register(struct iwl_trans *trans); |
| @@ -3318,7 +3318,8 @@ static void iwl_trans_pcie_resume(struct iwl_trans *trans) · 3317 unmodified lines | ||
| 3318 | 3318 | .unref = iwl_trans_pcie_unref, \ |
| 3319 | 3319 | .dump_data = iwl_trans_pcie_dump_data, \ |
| 3320 | 3320 | .d3_suspend = iwl_trans_pcie_d3_suspend, \ |
| 3321 | − .d3_resume = iwl_trans_pcie_d3_resume | |
| 3321 | + .d3_resume = iwl_trans_pcie_d3_resume, \ | |
| 3322 | + .sync_nmi = iwl_trans_pcie_sync_nmi | |
| 3322 | 3323 | |
| 3323 | 3324 | #ifdef CONFIG_PM_SLEEP |
| 3324 | 3325 | #define IWL_TRANS_PM_OPS \ |
| @@ -3542,6 +3543,10 @@ struct iwl_trans *iwl_trans_pcie_alloc(struct pci_dev *pdev, · 217 unmodified lines | ||
| 3542 | 3543 | } |
| 3543 | 3544 | } else if (cfg == &iwl_ax101_cfg_qu_hr) { |
| 3544 | 3545 | if (CSR_HW_RF_ID_TYPE_CHIP_ID(trans->hw_rf_id) == |
| 3546 | + CSR_HW_RF_ID_TYPE_CHIP_ID(CSR_HW_RF_ID_TYPE_HR) && | |
| 3547 | + trans->hw_rev == CSR_HW_REV_TYPE_QNJ_B0) { | |
| 3548 | + trans->cfg = &iwl22000_2ax_cfg_qnj_hr_b0; | |
| 3549 | + } else if (CSR_HW_RF_ID_TYPE_CHIP_ID(trans->hw_rf_id) == | |
| 3545 | 3550 | CSR_HW_RF_ID_TYPE_CHIP_ID(CSR_HW_RF_ID_TYPE_HR)) { |
| 3546 | 3551 | trans->cfg = &iwl_ax101_cfg_qu_hr; |
| 3547 | 3552 | } else if (CSR_HW_RF_ID_TYPE_CHIP_ID(trans->hw_rf_id) == |
| @@ -3560,7 +3565,7 @@ struct iwl_trans *iwl_trans_pcie_alloc(struct pci_dev *pdev, · 12 unmodified lines | ||
| 3560 | 3565 | } |
| 3561 | 3566 | } else if (CSR_HW_RF_ID_TYPE_CHIP_ID(trans->hw_rf_id) == |
| 3562 | 3567 | CSR_HW_RF_ID_TYPE_CHIP_ID(CSR_HW_RF_ID_TYPE_HR) && |
| 3563 | − (trans->cfg != &iwl22260_2ax_cfg || | |
| 3568 | + (trans->cfg != &iwl_ax200_cfg_cc || | |
| 3564 | 3569 | trans->hw_rev == CSR_HW_REV_TYPE_QNJ_B0)) { |
| 3565 | 3570 | u32 hw_status; |
| 3566 | 3571 | |
| @@ -3637,7 +3642,7 @@ out_no_pci: · 70 unmodified lines | ||
| 3637 | 3642 | return ERR_PTR(ret); |
| 3638 | 3643 | } |
| 3639 | 3644 | |
| 3640 | −void iwl_trans_sync_nmi(struct iwl_trans *trans) | |
| 3645 | +void iwl_trans_pcie_sync_nmi(struct iwl_trans *trans) | |
| 3641 | 3646 | { |
| 3642 | 3647 | unsigned long timeout = jiffies + IWL_TRANS_NMI_TIMEOUT; |
| 3643 | 3648 | |
| @@ -965,7 +965,7 @@ static int iwl_pcie_gen2_send_hcmd_sync(struct iwl_trans *trans, · 964 unmodified lines | ||
| 965 | 965 | cmd_str); |
| 966 | 966 | ret = -ETIMEDOUT; |
| 967 | 967 | |
| 968 | − iwl_trans_sync_nmi(trans); | |
| 968 | + iwl_trans_pcie_sync_nmi(trans); | |
| 969 | 969 | goto cancel; |
| 970 | 970 | } |
| 971 | 971 | |
| @@ -1960,7 +1960,7 @@ static int iwl_pcie_send_hcmd_sync(struct iwl_trans *trans, · 1959 unmodified lines | ||
| 1960 | 1960 | iwl_get_cmd_string(trans, cmd->id)); |
| 1961 | 1961 | ret = -ETIMEDOUT; |
| 1962 | 1962 | |
| 1963 | − iwl_trans_sync_nmi(trans); | |
| 1963 | + iwl_trans_pcie_sync_nmi(trans); | |
| 1964 | 1964 | goto cancel; |
| 1965 | 1965 | } |
| 1966 | 1966 | |
| @@ -2644,7 +2644,7 @@ static int mac80211_hwsim_new_radio(struct genl_info *info, · 2643 unmodified lines | ||
| 2644 | 2644 | enum nl80211_band band; |
| 2645 | 2645 | const struct ieee80211_ops *ops = &mac80211_hwsim_ops; |
| 2646 | 2646 | struct net *net; |
| 2647 | − int idx; | |
| 2647 | + int idx, i; | |
| 2648 | 2648 | int n_limits = 0; |
| 2649 | 2649 | |
| 2650 | 2650 | if (WARN_ON(param->channels > 1 && !param->use_chanctx)) |
| @@ -2768,12 +2768,23 @@ static int mac80211_hwsim_new_radio(struct genl_info *info, · 117 unmodified lines | ||
| 2768 | 2768 | goto failed_hw; |
| 2769 | 2769 | } |
| 2770 | 2770 | |
| 2771 | + data->if_combination.max_interfaces = 0; | |
| 2772 | + for (i = 0; i < n_limits; i++) | |
| 2773 | + data->if_combination.max_interfaces += | |
| 2774 | + data->if_limits[i].max; | |
| 2775 | + | |
| 2771 | 2776 | data->if_combination.n_limits = n_limits; |
| 2772 | − data->if_combination.max_interfaces = 2048; | |
| 2773 | 2777 | data->if_combination.limits = data->if_limits; |
| 2774 | 2778 | |
| 2775 | − hw->wiphy->iface_combinations = &data->if_combination; | |
| 2776 | − hw->wiphy->n_iface_combinations = 1; | |
| 2779 | + /* | |
| 2780 | + * If we actually were asked to support combinations, | |
| 2781 | + * advertise them - if there's only a single thing like | |
| 2782 | + * only IBSS then don't advertise it as combinations. | |
| 2783 | + */ | |
| 2784 | + if (data->if_combination.max_interfaces > 1) { | |
| 2785 | + hw->wiphy->iface_combinations = &data->if_combination; | |
| 2786 | + hw->wiphy->n_iface_combinations = 1; | |
| 2787 | + } | |
| 2777 | 2788 | |
| 2778 | 2789 | if (param->ciphers) { |
| 2779 | 2790 | memcpy(data->ciphers, param->ciphers, |
| @@ -510,6 +510,8 @@ int mt7603_register_device(struct mt7603_dev *dev) · 509 unmodified lines | ||
| 510 | 510 | bus_ops->rmw = mt7603_rmw; |
| 511 | 511 | dev->mt76.bus = bus_ops; |
| 512 | 512 | |
| 513 | + spin_lock_init(&dev->ps_lock); | |
| 514 | + | |
| 513 | 515 | INIT_DELAYED_WORK(&dev->mac_work, mt7603_mac_work); |
| 514 | 516 | tasklet_init(&dev->pre_tbtt_tasklet, mt7603_pre_tbtt_tasklet, |
| 515 | 517 | (unsigned long)dev); |
| @@ -343,7 +343,7 @@ void mt7603_mac_rx_ba_reset(struct mt7603_dev *dev, void *addr, u8 tid) · 342 unmodified lines | ||
| 343 | 343 | MT_BA_CONTROL_1_RESET)); |
| 344 | 344 | } |
| 345 | 345 | |
| 346 | −void mt7603_mac_tx_ba_reset(struct mt7603_dev *dev, int wcid, int tid, int ssn, | |
| 346 | +void mt7603_mac_tx_ba_reset(struct mt7603_dev *dev, int wcid, int tid, | |
| 347 | 347 | int ba_size) |
| 348 | 348 | { |
| 349 | 349 | u32 addr = mt7603_wtbl2_addr(wcid); |
| @@ -358,43 +358,6 @@ void mt7603_mac_tx_ba_reset(struct mt7603_dev *dev, int wcid, int tid, int ssn, · 8 unmodified lines | ||
| 358 | 358 | mt76_clear(dev, addr + (15 * 4), tid_mask); |
| 359 | 359 | return; |
| 360 | 360 | } |
| 361 | − mt76_poll(dev, MT_WTBL_UPDATE, MT_WTBL_UPDATE_BUSY, 0, 5000); | |
| 362 | − | |
| 363 | − mt7603_mac_stop(dev); | |
| 364 | − switch (tid) { | |
| 365 | − case 0: | |
| 366 | − mt76_rmw_field(dev, addr + (2 * 4), MT_WTBL2_W2_TID0_SN, ssn); | |
| 367 | − break; | |
| 368 | − case 1: | |
| 369 | − mt76_rmw_field(dev, addr + (2 * 4), MT_WTBL2_W2_TID1_SN, ssn); | |
| 370 | − break; | |
| 371 | − case 2: | |
| 372 | − mt76_rmw_field(dev, addr + (2 * 4), MT_WTBL2_W2_TID2_SN_LO, | |
| 373 | − ssn); | |
| 374 | − mt76_rmw_field(dev, addr + (3 * 4), MT_WTBL2_W3_TID2_SN_HI, | |
| 375 | − ssn >> 8); | |
| 376 | − break; | |
| 377 | − case 3: | |
| 378 | − mt76_rmw_field(dev, addr + (3 * 4), MT_WTBL2_W3_TID3_SN, ssn); | |
| 379 | − break; | |
| 380 | − case 4: | |
| 381 | − mt76_rmw_field(dev, addr + (3 * 4), MT_WTBL2_W3_TID4_SN, ssn); | |
| 382 | − break; | |
| 383 | − case 5: | |
| 384 | − mt76_rmw_field(dev, addr + (3 * 4), MT_WTBL2_W3_TID5_SN_LO, | |
| 385 | − ssn); | |
| 386 | − mt76_rmw_field(dev, addr + (4 * 4), MT_WTBL2_W4_TID5_SN_HI, | |
| 387 | − ssn >> 4); | |
| 388 | − break; | |
| 389 | − case 6: | |
| 390 | − mt76_rmw_field(dev, addr + (4 * 4), MT_WTBL2_W4_TID6_SN, ssn); | |
| 391 | − break; | |
| 392 | − case 7: | |
| 393 | − mt76_rmw_field(dev, addr + (4 * 4), MT_WTBL2_W4_TID7_SN, ssn); | |
| 394 | − break; | |
| 395 | − } | |
| 396 | − mt7603_wtbl_update(dev, wcid, MT_WTBL_UPDATE_WTBL2); | |
| 397 | − mt7603_mac_start(dev); | |
| 398 | 361 | |
| 399 | 362 | for (i = 7; i > 0; i--) { |
| 400 | 363 | if (ba_size >= MT_AGG_SIZE_LIMIT(i)) |
| @@ -827,6 +790,7 @@ mt7603_mac_write_txwi(struct mt7603_dev *dev, __le32 *txwi, · 426 unmodified lines | ||
| 827 | 790 | struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); |
| 828 | 791 | struct ieee80211_tx_rate *rate = &info->control.rates[0]; |
| 829 | 792 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; |
| 793 | + struct ieee80211_bar *bar = (struct ieee80211_bar *)skb->data; | |
| 830 | 794 | struct ieee80211_vif *vif = info->control.vif; |
| 831 | 795 | struct mt7603_vif *mvif; |
| 832 | 796 | int wlan_idx; |
| @@ -834,6 +798,7 @@ mt7603_mac_write_txwi(struct mt7603_dev *dev, __le32 *txwi, · 1 unmodified line | ||
| 834 | 798 | int tx_count = 8; |
| 835 | 799 | u8 frame_type, frame_subtype; |
| 836 | 800 | u16 fc = le16_to_cpu(hdr->frame_control); |
| 801 | + u16 seqno = 0; | |
| 837 | 802 | u8 vif_idx = 0; |
| 838 | 803 | u32 val; |
| 839 | 804 | u8 bw; |
| @@ -919,7 +884,17 @@ mt7603_mac_write_txwi(struct mt7603_dev *dev, __le32 *txwi, · 79 unmodified lines | ||
| 919 | 884 | tx_count = 0x1f; |
| 920 | 885 | |
| 921 | 886 | val = FIELD_PREP(MT_TXD3_REM_TX_COUNT, tx_count) | |
| 922 | − FIELD_PREP(MT_TXD3_SEQ, le16_to_cpu(hdr->seq_ctrl)); | |
| 887 | + MT_TXD3_SN_VALID; | |
| 888 | + | |
| 889 | + if (ieee80211_is_data_qos(hdr->frame_control)) | |
| 890 | + seqno = le16_to_cpu(hdr->seq_ctrl); | |
| 891 | + else if (ieee80211_is_back_req(hdr->frame_control)) | |
| 892 | + seqno = le16_to_cpu(bar->start_seq_num); | |
| 893 | + else | |
| 894 | + val &= ~MT_TXD3_SN_VALID; | |
| 895 | + | |
| 896 | + val |= FIELD_PREP(MT_TXD3_SEQ, seqno >> 4); | |
| 897 | + | |
| 923 | 898 | txwi[3] = cpu_to_le32(val); |
| 924 | 899 | |
| 925 | 900 | if (key) { |
| @@ -372,7 +372,7 @@ mt7603_sta_ps(struct mt76_dev *mdev, struct ieee80211_sta *sta, bool ps) · 371 unmodified lines | ||
| 372 | 372 | struct mt7603_sta *msta = (struct mt7603_sta *)sta->drv_priv; |
| 373 | 373 | struct sk_buff_head list; |
| 374 | 374 | |
| 375 | − mt76_stop_tx_queues(&dev->mt76, sta, false); | |
| 375 | + mt76_stop_tx_queues(&dev->mt76, sta, true); | |
| 376 | 376 | mt7603_wtbl_set_ps(dev, msta, ps); |
| 377 | 377 | if (ps) |
| 378 | 378 | return; |
| @@ -584,13 +584,13 @@ mt7603_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif, · 205 unmodified lines | ||
| 584 | 584 | case IEEE80211_AMPDU_TX_OPERATIONAL: |
| 585 | 585 | mtxq->aggr = true; |
| 586 | 586 | mtxq->send_bar = false; |
| 587 | − mt7603_mac_tx_ba_reset(dev, msta->wcid.idx, tid, *ssn, ba_size); | |
| 587 | + mt7603_mac_tx_ba_reset(dev, msta->wcid.idx, tid, ba_size); | |
| 588 | 588 | break; |
| 589 | 589 | case IEEE80211_AMPDU_TX_STOP_FLUSH: |
| 590 | 590 | case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: |
| 591 | 591 | mtxq->aggr = false; |
| 592 | 592 | ieee80211_send_bar(vif, sta->addr, tid, mtxq->agg_ssn); |
| 593 | − mt7603_mac_tx_ba_reset(dev, msta->wcid.idx, tid, *ssn, -1); | |
| 593 | + mt7603_mac_tx_ba_reset(dev, msta->wcid.idx, tid, -1); | |
| 594 | 594 | break; |
| 595 | 595 | case IEEE80211_AMPDU_TX_START: |
| 596 | 596 | mtxq->agg_ssn = *ssn << 4; |
| @@ -598,7 +598,7 @@ mt7603_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif, · 1 unmodified line | ||
| 598 | 598 | break; |
| 599 | 599 | case IEEE80211_AMPDU_TX_STOP_CONT: |
| 600 | 600 | mtxq->aggr = false; |
| 601 | − mt7603_mac_tx_ba_reset(dev, msta->wcid.idx, tid, *ssn, -1); | |
| 601 | + mt7603_mac_tx_ba_reset(dev, msta->wcid.idx, tid, -1); | |
| 602 | 602 | ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid); |
| 603 | 603 | break; |
| 604 | 604 | } |
| @@ -200,7 +200,7 @@ void mt7603_beacon_set_timer(struct mt7603_dev *dev, int idx, int intval); · 199 unmodified lines | ||
| 200 | 200 | int mt7603_mac_fill_rx(struct mt7603_dev *dev, struct sk_buff *skb); |
| 201 | 201 | void mt7603_mac_add_txs(struct mt7603_dev *dev, void *data); |
| 202 | 202 | void mt7603_mac_rx_ba_reset(struct mt7603_dev *dev, void *addr, u8 tid); |
| 203 | −void mt7603_mac_tx_ba_reset(struct mt7603_dev *dev, int wcid, int tid, int ssn, | |
| 203 | +void mt7603_mac_tx_ba_reset(struct mt7603_dev *dev, int wcid, int tid, | |
| 204 | 204 | int ba_size); |
| 205 | 205 | |
| 206 | 206 | void mt7603_pse_client_reset(struct mt7603_dev *dev); |
| @@ -466,7 +466,6 @@ void mt76x02_send_tx_status(struct mt76x02_dev *dev, · 465 unmodified lines | ||
| 466 | 466 | return; |
| 467 | 467 | |
| 468 | 468 | rcu_read_lock(); |
| 469 | − mt76_tx_status_lock(mdev, &list); | |
| 470 | 469 | |
| 471 | 470 | if (stat->wcid < ARRAY_SIZE(dev->mt76.wcid)) |
| 472 | 471 | wcid = rcu_dereference(dev->mt76.wcid[stat->wcid]); |
| @@ -479,6 +478,8 @@ void mt76x02_send_tx_status(struct mt76x02_dev *dev, · 6 unmodified lines | ||
| 479 | 478 | drv_priv); |
| 480 | 479 | } |
| 481 | 480 | |
| 481 | + mt76_tx_status_lock(mdev, &list); | |
| 482 | + | |
| 482 | 483 | if (wcid) { |
| 483 | 484 | if (stat->pktid >= MT_PACKET_ID_FIRST) |
| 484 | 485 | status.skb = mt76_tx_status_skb_get(mdev, wcid, |
| @@ -498,7 +499,9 @@ void mt76x02_send_tx_status(struct mt76x02_dev *dev, · 13 unmodified lines | ||
| 498 | 499 | if (*update == 0 && stat_val == stat_cache && |
| 499 | 500 | stat->wcid == msta->status.wcid && msta->n_frames < 32) { |
| 500 | 501 | msta->n_frames++; |
| 501 | − goto out; | |
| 502 | + mt76_tx_status_unlock(mdev, &list); | |
| 503 | + rcu_read_unlock(); | |
| 504 | + return; | |
| 502 | 505 | } |
| 503 | 506 | |
| 504 | 507 | mt76x02_mac_fill_tx_status(dev, status.info, &msta->status, |
| @@ -514,11 +517,10 @@ void mt76x02_send_tx_status(struct mt76x02_dev *dev, · 9 unmodified lines | ||
| 514 | 517 | |
| 515 | 518 | if (status.skb) |
| 516 | 519 | mt76_tx_status_skb_done(mdev, status.skb, &list); |
| 517 | − else | |
| 518 | − ieee80211_tx_status_ext(mt76_hw(dev), &status); | |
| 519 | − | |
| 520 | −out: | |
| 521 | 520 | mt76_tx_status_unlock(mdev, &list); |
| 521 | + | |
| 522 | + if (!status.skb) | |
| 523 | + ieee80211_tx_status_ext(mt76_hw(dev), &status); | |
| 522 | 524 | rcu_read_unlock(); |
| 523 | 525 | } |
| 524 | 526 | |
| @@ -673,7 +673,6 @@ enum rt2x00_state_flags { · 672 unmodified lines | ||
| 673 | 673 | CONFIG_CHANNEL_HT40, |
| 674 | 674 | CONFIG_POWERSAVING, |
| 675 | 675 | CONFIG_HT_DISABLED, |
| 676 | − CONFIG_QOS_DISABLED, | |
| 677 | 676 | CONFIG_MONITORING, |
| 678 | 677 | |
| 679 | 678 | /* |
| @@ -642,18 +642,8 @@ void rt2x00mac_bss_info_changed(struct ieee80211_hw *hw, · 641 unmodified lines | ||
| 642 | 642 | rt2x00dev->intf_associated--; |
| 643 | 643 | |
| 644 | 644 | rt2x00leds_led_assoc(rt2x00dev, !!rt2x00dev->intf_associated); |
| 645 | − | |
| 646 | − clear_bit(CONFIG_QOS_DISABLED, &rt2x00dev->flags); | |
| 647 | 645 | } |
| 648 | 646 | |
| 649 | − /* | |
| 650 | − * Check for access point which do not support 802.11e . We have to | |
| 651 | − * generate data frames sequence number in S/W for such AP, because | |
| 652 | − * of H/W bug. | |
| 653 | − */ | |
| 654 | − if (changes & BSS_CHANGED_QOS && !bss_conf->qos) | |
| 655 | − set_bit(CONFIG_QOS_DISABLED, &rt2x00dev->flags); | |
| 656 | − | |
| 657 | 647 | /* |
| 658 | 648 | * When the erp information has changed, we should perform |
| 659 | 649 | * additional configuration steps. For all other changes we are done. |
| @@ -201,15 +201,18 @@ static void rt2x00queue_create_tx_descriptor_seq(struct rt2x00_dev *rt2x00dev, · 200 unmodified lines | ||
| 201 | 201 | if (!rt2x00_has_cap_flag(rt2x00dev, REQUIRE_SW_SEQNO)) { |
| 202 | 202 | /* |
| 203 | 203 | * rt2800 has a H/W (or F/W) bug, device incorrectly increase |
| 204 | − * seqno on retransmited data (non-QOS) frames. To workaround | |
| 205 | − * the problem let's generate seqno in software if QOS is | |
| 206 | − * disabled. | |
| 204 | + * seqno on retransmitted data (non-QOS) and management frames. | |
| 205 | + * To workaround the problem let's generate seqno in software. | |
| 206 | + * Except for beacons which are transmitted periodically by H/W | |
| 207 | + * hence hardware has to assign seqno for them. | |
| 207 | 208 | */ |
| 208 | − if (test_bit(CONFIG_QOS_DISABLED, &rt2x00dev->flags)) | |
| 209 | − __clear_bit(ENTRY_TXD_GENERATE_SEQ, &txdesc->flags); | |
| 210 | − else | |
| 209 | + if (ieee80211_is_beacon(hdr->frame_control)) { | |
| 210 | + __set_bit(ENTRY_TXD_GENERATE_SEQ, &txdesc->flags); | |
| 211 | 211 | /* H/W will generate sequence number */ |
| 212 | 212 | return; |
| 213 | + } | |
| 214 | + | |
| 215 | + __clear_bit(ENTRY_TXD_GENERATE_SEQ, &txdesc->flags); | |
| 213 | 216 | } |
| 214 | 217 | |
| 215 | 218 | /* |
| @@ -198,14 +198,15 @@ static struct device *__nd_btt_create(struct nd_region *nd_region, · 197 unmodified lines | ||
| 198 | 198 | return NULL; |
| 199 | 199 | |
| 200 | 200 | nd_btt->id = ida_simple_get(&nd_region->btt_ida, 0, 0, GFP_KERNEL); |
| 201 | − if (nd_btt->id < 0) { | |
| 202 | − kfree(nd_btt); | |
| 203 | − return NULL; | |
| 204 | − } | |
| 201 | + if (nd_btt->id < 0) | |
| 202 | + goto out_nd_btt; | |
| 205 | 203 | |
| 206 | 204 | nd_btt->lbasize = lbasize; |
| 207 | − if (uuid) | |
| 205 | + if (uuid) { | |
| 208 | 206 | uuid = kmemdup(uuid, 16, GFP_KERNEL); |
| 207 | + if (!uuid) | |
| 208 | + goto out_put_id; | |
| 209 | + } | |
| 209 | 210 | nd_btt->uuid = uuid; |
| 210 | 211 | dev = &nd_btt->dev; |
| 211 | 212 | dev_set_name(dev, "btt%d.%d", nd_region->id, nd_btt->id); |
| @@ -220,6 +221,13 @@ static struct device *__nd_btt_create(struct nd_region *nd_region, · 8 unmodified lines | ||
| 220 | 221 | return NULL; |
| 221 | 222 | } |
| 222 | 223 | return dev; |
| 224 | + | |
| 225 | +out_put_id: | |
| 226 | + ida_simple_remove(&nd_region->btt_ida, nd_btt->id); | |
| 227 | + | |
| 228 | +out_nd_btt: | |
| 229 | + kfree(nd_btt); | |
| 230 | + return NULL; | |
| 223 | 231 | } |
| 224 | 232 | |
| 225 | 233 | struct device *nd_btt_create(struct nd_region *nd_region) |
| @@ -2249,9 +2249,12 @@ static struct device *create_namespace_blk(struct nd_region *nd_region, · 2248 unmodified lines | ||
| 2249 | 2249 | if (!nsblk->uuid) |
| 2250 | 2250 | goto blk_err; |
| 2251 | 2251 | memcpy(name, nd_label->name, NSLABEL_NAME_LEN); |
| 2252 | − if (name[0]) | |
| 2252 | + if (name[0]) { | |
| 2253 | 2253 | nsblk->alt_name = kmemdup(name, NSLABEL_NAME_LEN, |
| 2254 | 2254 | GFP_KERNEL); |
| 2255 | + if (!nsblk->alt_name) | |
| 2256 | + goto blk_err; | |
| 2257 | + } | |
| 2255 | 2258 | res = nsblk_add_resource(nd_region, ndd, nsblk, |
| 2256 | 2259 | __le64_to_cpu(nd_label->dpa)); |
| 2257 | 2260 | if (!res) |
| @@ -113,13 +113,13 @@ static void write_pmem(void *pmem_addr, struct page *page, · 112 unmodified lines | ||
| 113 | 113 | |
| 114 | 114 | while (len) { |
| 115 | 115 | mem = kmap_atomic(page); |
| 116 | − chunk = min_t(unsigned int, len, PAGE_SIZE); | |
| 116 | + chunk = min_t(unsigned int, len, PAGE_SIZE - off); | |
| 117 | 117 | memcpy_flushcache(pmem_addr, mem + off, chunk); |
| 118 | 118 | kunmap_atomic(mem); |
| 119 | 119 | len -= chunk; |
| 120 | 120 | off = 0; |
| 121 | 121 | page++; |
| 122 | − pmem_addr += PAGE_SIZE; | |
| 122 | + pmem_addr += chunk; | |
| 123 | 123 | } |
| 124 | 124 | } |
| 125 | 125 | |
| @@ -132,7 +132,7 @@ static blk_status_t read_pmem(struct page *page, unsigned int off, · 6 unmodified lines | ||
| 132 | 132 | |
| 133 | 133 | while (len) { |
| 134 | 134 | mem = kmap_atomic(page); |
| 135 | − chunk = min_t(unsigned int, len, PAGE_SIZE); | |
| 135 | + chunk = min_t(unsigned int, len, PAGE_SIZE - off); | |
| 136 | 136 | rem = memcpy_mcsafe(mem + off, pmem_addr, chunk); |
| 137 | 137 | kunmap_atomic(mem); |
| 138 | 138 | if (rem) |
| @@ -140,7 +140,7 @@ static blk_status_t read_pmem(struct page *page, unsigned int off, · 1 unmodified line | ||
| 140 | 140 | len -= chunk; |
| 141 | 141 | off = 0; |
| 142 | 142 | page++; |
| 143 | − pmem_addr += PAGE_SIZE; | |
| 143 | + pmem_addr += chunk; | |
| 144 | 144 | } |
| 145 | 145 | return BLK_STS_OK; |
| 146 | 146 | } |
| @@ -22,6 +22,8 @@ static bool key_revalidate = true; · 21 unmodified lines | ||
| 22 | 22 | module_param(key_revalidate, bool, 0444); |
| 23 | 23 | MODULE_PARM_DESC(key_revalidate, "Require key validation at init."); |
| 24 | 24 | |
| 25 | +static const char zero_key[NVDIMM_PASSPHRASE_LEN]; | |
| 26 | + | |
| 25 | 27 | static void *key_data(struct key *key) |
| 26 | 28 | { |
| 27 | 29 | struct encrypted_key_payload *epayload = dereference_key_locked(key); |
| @@ -75,6 +77,16 @@ static struct key *nvdimm_request_key(struct nvdimm *nvdimm) · 47 unmodified lines | ||
| 75 | 77 | return key; |
| 76 | 78 | } |
| 77 | 79 | |
| 80 | +static const void *nvdimm_get_key_payload(struct nvdimm *nvdimm, | |
| 81 | + struct key **key) | |
| 82 | +{ | |
| 83 | + *key = nvdimm_request_key(nvdimm); | |
| 84 | + if (!*key) | |
| 85 | + return zero_key; | |
| 86 | + | |
| 87 | + return key_data(*key); | |
| 88 | +} | |
| 89 | + | |
| 78 | 90 | static struct key *nvdimm_lookup_user_key(struct nvdimm *nvdimm, |
| 79 | 91 | key_serial_t id, int subclass) |
| 80 | 92 | { |
| @@ -105,36 +117,57 @@ static struct key *nvdimm_lookup_user_key(struct nvdimm *nvdimm, · 24 unmodified lines | ||
| 105 | 117 | return key; |
| 106 | 118 | } |
| 107 | 119 | |
| 108 | −static struct key *nvdimm_key_revalidate(struct nvdimm *nvdimm) | |
| 120 | +static const void *nvdimm_get_user_key_payload(struct nvdimm *nvdimm, | |
| 121 | + key_serial_t id, int subclass, struct key **key) | |
| 122 | +{ | |
| 123 | + *key = NULL; | |
| 124 | + if (id == 0) { | |
| 125 | + if (subclass == NVDIMM_BASE_KEY) | |
| 126 | + return zero_key; | |
| 127 | + else | |
| 128 | + return NULL; | |
| 129 | + } | |
| 130 | + | |
| 131 | + *key = nvdimm_lookup_user_key(nvdimm, id, subclass); | |
| 132 | + if (!*key) | |
| 133 | + return NULL; | |
| 134 | + | |
| 135 | + return key_data(*key); | |
| 136 | +} | |
| 137 | + | |
| 138 | + | |
| 139 | +static int nvdimm_key_revalidate(struct nvdimm *nvdimm) | |
| 109 | 140 | { |
| 110 | 141 | struct key *key; |
| 111 | 142 | int rc; |
| 143 | + const void *data; | |
| 112 | 144 | |
| 113 | 145 | if (!nvdimm->sec.ops->change_key) |
| 114 | − return NULL; | |
| 146 | + return -EOPNOTSUPP; | |
| 115 | 147 | |
| 116 | − key = nvdimm_request_key(nvdimm); | |
| 117 | − if (!key) | |
| 118 | − return NULL; | |
| 148 | + data = nvdimm_get_key_payload(nvdimm, &key); | |
| 119 | 149 | |
| 120 | 150 | /* |
| 121 | 151 | * Send the same key to the hardware as new and old key to |
| 122 | 152 | * verify that the key is good. |
| 123 | 153 | */ |
| 124 | − rc = nvdimm->sec.ops->change_key(nvdimm, key_data(key), | |
| 125 | − key_data(key), NVDIMM_USER); | |
| 154 | + rc = nvdimm->sec.ops->change_key(nvdimm, data, data, NVDIMM_USER); | |
| 126 | 155 | if (rc < 0) { |
| 127 | 156 | nvdimm_put_key(key); |
| 128 | − key = NULL; | |
| 157 | + return rc; | |
| 129 | 158 | } |
| 130 | − return key; | |
| 159 | + | |
| 160 | + nvdimm_put_key(key); | |
| 161 | + nvdimm->sec.state = nvdimm_security_state(nvdimm, NVDIMM_USER); | |
| 162 | + return 0; | |
| 131 | 163 | } |
| 132 | 164 | |
| 133 | 165 | static int __nvdimm_security_unlock(struct nvdimm *nvdimm) |
| 134 | 166 | { |
| 135 | 167 | struct device *dev = &nvdimm->dev; |
| 136 | 168 | struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev); |
| 137 | − struct key *key = NULL; | |
| 169 | + struct key *key; | |
| 170 | + const void *data; | |
| 138 | 171 | int rc; |
| 139 | 172 | |
| 140 | 173 | /* The bus lock should be held at the top level of the call stack */ |
| @@ -160,16 +193,11 @@ static int __nvdimm_security_unlock(struct nvdimm *nvdimm) · 19 unmodified lines | ||
| 160 | 193 | if (!key_revalidate) |
| 161 | 194 | return 0; |
| 162 | 195 | |
| 163 | − key = nvdimm_key_revalidate(nvdimm); | |
| 164 | − if (!key) | |
| 165 | − return nvdimm_security_freeze(nvdimm); | |
| 196 | + return nvdimm_key_revalidate(nvdimm); | |
| 166 | 197 | } else |
| 167 | − key = nvdimm_request_key(nvdimm); | |
| 198 | + data = nvdimm_get_key_payload(nvdimm, &key); | |
| 168 | 199 | |
| 169 | − if (!key) | |
| 170 | − return -ENOKEY; | |
| 171 | − | |
| 172 | − rc = nvdimm->sec.ops->unlock(nvdimm, key_data(key)); | |
| 200 | + rc = nvdimm->sec.ops->unlock(nvdimm, data); | |
| 173 | 201 | dev_dbg(dev, "key: %d unlock: %s\n", key_serial(key), |
| 174 | 202 | rc == 0 ? "success" : "fail"); |
| 175 | 203 | |
| @@ -195,6 +223,7 @@ int nvdimm_security_disable(struct nvdimm *nvdimm, unsigned int keyid) · 19 unmodified lines | ||
| 195 | 223 | struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev); |
| 196 | 224 | struct key *key; |
| 197 | 225 | int rc; |
| 226 | + const void *data; | |
| 198 | 227 | |
| 199 | 228 | /* The bus lock should be held at the top level of the call stack */ |
| 200 | 229 | lockdep_assert_held(&nvdimm_bus->reconfig_mutex); |
| @@ -214,11 +243,12 @@ int nvdimm_security_disable(struct nvdimm *nvdimm, unsigned int keyid) · 13 unmodified lines | ||
| 214 | 243 | return -EBUSY; |
| 215 | 244 | } |
| 216 | 245 | |
| 217 | − key = nvdimm_lookup_user_key(nvdimm, keyid, NVDIMM_BASE_KEY); | |
| 218 | − if (!key) | |
| 246 | + data = nvdimm_get_user_key_payload(nvdimm, keyid, | |
| 247 | + NVDIMM_BASE_KEY, &key); | |
| 248 | + if (!data) | |
| 219 | 249 | return -ENOKEY; |
| 220 | 250 | |
| 221 | − rc = nvdimm->sec.ops->disable(nvdimm, key_data(key)); | |
| 251 | + rc = nvdimm->sec.ops->disable(nvdimm, data); | |
| 222 | 252 | dev_dbg(dev, "key: %d disable: %s\n", key_serial(key), |
| 223 | 253 | rc == 0 ? "success" : "fail"); |
| 224 | 254 | |
| @@ -235,6 +265,7 @@ int nvdimm_security_update(struct nvdimm *nvdimm, unsigned int keyid, · 10 unmodified lines | ||
| 235 | 265 | struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev); |
| 236 | 266 | struct key *key, *newkey; |
| 237 | 267 | int rc; |
| 268 | + const void *data, *newdata; | |
| 238 | 269 | |
| 239 | 270 | /* The bus lock should be held at the top level of the call stack */ |
| 240 | 271 | lockdep_assert_held(&nvdimm_bus->reconfig_mutex); |
| @@ -249,22 +280,19 @@ int nvdimm_security_update(struct nvdimm *nvdimm, unsigned int keyid, · 8 unmodified lines | ||
| 249 | 280 | return -EIO; |
| 250 | 281 | } |
| 251 | 282 | |
| 252 | − if (keyid == 0) | |
| 253 | − key = NULL; | |
| 254 | − else { | |
| 255 | − key = nvdimm_lookup_user_key(nvdimm, keyid, NVDIMM_BASE_KEY); | |
| 256 | − if (!key) | |
| 257 | − return -ENOKEY; | |
| 258 | − } | |
| 283 | + data = nvdimm_get_user_key_payload(nvdimm, keyid, | |
| 284 | + NVDIMM_BASE_KEY, &key); | |
| 285 | + if (!data) | |
| 286 | + return -ENOKEY; | |
| 259 | 287 | |
| 260 | − newkey = nvdimm_lookup_user_key(nvdimm, new_keyid, NVDIMM_NEW_KEY); | |
| 261 | − if (!newkey) { | |
| 288 | + newdata = nvdimm_get_user_key_payload(nvdimm, new_keyid, | |
| 289 | + NVDIMM_NEW_KEY, &newkey); | |
| 290 | + if (!newdata) { | |
| 262 | 291 | nvdimm_put_key(key); |
| 263 | 292 | return -ENOKEY; |
| 264 | 293 | } |
| 265 | 294 | |
| 266 | − rc = nvdimm->sec.ops->change_key(nvdimm, key ? key_data(key) : NULL, | |
| 267 | − key_data(newkey), pass_type); | |
| 295 | + rc = nvdimm->sec.ops->change_key(nvdimm, data, newdata, pass_type); | |
| 268 | 296 | dev_dbg(dev, "key: %d %d update%s: %s\n", |
| 269 | 297 | key_serial(key), key_serial(newkey), |
| 270 | 298 | pass_type == NVDIMM_MASTER ? "(master)" : "(user)", |
| @@ -286,8 +314,9 @@ int nvdimm_security_erase(struct nvdimm *nvdimm, unsigned int keyid, · 15 unmodified lines | ||
| 286 | 314 | { |
| 287 | 315 | struct device *dev = &nvdimm->dev; |
| 288 | 316 | struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev); |
| 289 | − struct key *key; | |
| 317 | + struct key *key = NULL; | |
| 290 | 318 | int rc; |
| 319 | + const void *data; | |
| 291 | 320 | |
| 292 | 321 | /* The bus lock should be held at the top level of the call stack */ |
| 293 | 322 | lockdep_assert_held(&nvdimm_bus->reconfig_mutex); |
| @@ -319,11 +348,12 @@ int nvdimm_security_erase(struct nvdimm *nvdimm, unsigned int keyid, · 25 unmodified lines | ||
| 319 | 348 | return -EOPNOTSUPP; |
| 320 | 349 | } |
| 321 | 350 | |
| 322 | − key = nvdimm_lookup_user_key(nvdimm, keyid, NVDIMM_BASE_KEY); | |
| 323 | − if (!key) | |
| 351 | + data = nvdimm_get_user_key_payload(nvdimm, keyid, | |
| 352 | + NVDIMM_BASE_KEY, &key); | |
| 353 | + if (!data) | |
| 324 | 354 | return -ENOKEY; |
| 325 | 355 | |
| 326 | − rc = nvdimm->sec.ops->erase(nvdimm, key_data(key), pass_type); | |
| 356 | + rc = nvdimm->sec.ops->erase(nvdimm, data, pass_type); | |
| 327 | 357 | dev_dbg(dev, "key: %d erase%s: %s\n", key_serial(key), |
| 328 | 358 | pass_type == NVDIMM_MASTER ? "(master)" : "(user)", |
| 329 | 359 | rc == 0 ? "success" : "fail"); |
| @@ -337,8 +367,9 @@ int nvdimm_security_overwrite(struct nvdimm *nvdimm, unsigned int keyid) · 7 unmodified lines | ||
| 337 | 367 | { |
| 338 | 368 | struct device *dev = &nvdimm->dev; |
| 339 | 369 | struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev); |
| 340 | − struct key *key; | |
| 370 | + struct key *key = NULL; | |
| 341 | 371 | int rc; |
| 372 | + const void *data; | |
| 342 | 373 | |
| 343 | 374 | /* The bus lock should be held at the top level of the call stack */ |
| 344 | 375 | lockdep_assert_held(&nvdimm_bus->reconfig_mutex); |
| @@ -368,15 +399,12 @@ int nvdimm_security_overwrite(struct nvdimm *nvdimm, unsigned int keyid) · 23 unmodified lines | ||
| 368 | 399 | return -EBUSY; |
| 369 | 400 | } |
| 370 | 401 | |
| 371 | − if (keyid == 0) | |
| 372 | − key = NULL; | |
| 373 | − else { | |
| 374 | − key = nvdimm_lookup_user_key(nvdimm, keyid, NVDIMM_BASE_KEY); | |
| 375 | − if (!key) | |
| 376 | − return -ENOKEY; | |
| 377 | − } | |
| 402 | + data = nvdimm_get_user_key_payload(nvdimm, keyid, | |
| 403 | + NVDIMM_BASE_KEY, &key); | |
| 404 | + if (!data) | |
| 405 | + return -ENOKEY; | |
| 378 | 406 | |
| 379 | − rc = nvdimm->sec.ops->overwrite(nvdimm, key ? key_data(key) : NULL); | |
| 407 | + rc = nvdimm->sec.ops->overwrite(nvdimm, data); | |
| 380 | 408 | dev_dbg(dev, "key: %d overwrite submission: %s\n", key_serial(key), |
| 381 | 409 | rc == 0 ? "success" : "fail"); |
| 382 | 410 | |
| @@ -288,7 +288,7 @@ bool nvme_cancel_request(struct request *req, void *data, bool reserved) · 287 unmodified lines | ||
| 288 | 288 | "Cancelling I/O %d", req->tag); |
| 289 | 289 | |
| 290 | 290 | nvme_req(req)->status = NVME_SC_ABORT_REQ; |
| 291 | − blk_mq_complete_request(req); | |
| 291 | + blk_mq_complete_request_sync(req); | |
| 292 | 292 | return true; |
| 293 | 293 | } |
| 294 | 294 | EXPORT_SYMBOL_GPL(nvme_cancel_request); |
| @@ -1845,7 +1845,7 @@ nvme_fc_init_queue(struct nvme_fc_ctrl *ctrl, int idx) · 1844 unmodified lines | ||
| 1845 | 1845 | memset(queue, 0, sizeof(*queue)); |
| 1846 | 1846 | queue->ctrl = ctrl; |
| 1847 | 1847 | queue->qnum = idx; |
| 1848 | − atomic_set(&queue->csn, 1); | |
| 1848 | + atomic_set(&queue->csn, 0); | |
| 1849 | 1849 | queue->dev = ctrl->dev; |
| 1850 | 1850 | |
| 1851 | 1851 | if (idx > 0) |
| @@ -1887,7 +1887,7 @@ nvme_fc_free_queue(struct nvme_fc_queue *queue) · 35 unmodified lines | ||
| 1887 | 1887 | */ |
| 1888 | 1888 | |
| 1889 | 1889 | queue->connection_id = 0; |
| 1890 | − atomic_set(&queue->csn, 1); | |
| 1890 | + atomic_set(&queue->csn, 0); | |
| 1891 | 1891 | } |
| 1892 | 1892 | |
| 1893 | 1893 | static void |
| @@ -2183,7 +2183,6 @@ nvme_fc_start_fcp_op(struct nvme_fc_ctrl *ctrl, struct nvme_fc_queue *queue, · 289 unmodified lines | ||
| 2183 | 2183 | { |
| 2184 | 2184 | struct nvme_fc_cmd_iu *cmdiu = &op->cmd_iu; |
| 2185 | 2185 | struct nvme_command *sqe = &cmdiu->sqe; |
| 2186 | − u32 csn; | |
| 2187 | 2186 | int ret, opstate; |
| 2188 | 2187 | |
| 2189 | 2188 | /* |
| @@ -2198,8 +2197,6 @@ nvme_fc_start_fcp_op(struct nvme_fc_ctrl *ctrl, struct nvme_fc_queue *queue, · 8 unmodified lines | ||
| 2198 | 2197 | |
| 2199 | 2198 | /* format the FC-NVME CMD IU and fcp_req */ |
| 2200 | 2199 | cmdiu->connection_id = cpu_to_be64(queue->connection_id); |
| 2201 | − csn = atomic_inc_return(&queue->csn); | |
| 2202 | − cmdiu->csn = cpu_to_be32(csn); | |
| 2203 | 2200 | cmdiu->data_len = cpu_to_be32(data_len); |
| 2204 | 2201 | switch (io_dir) { |
| 2205 | 2202 | case NVMEFC_FCP_WRITE: |
| @@ -2257,11 +2254,24 @@ nvme_fc_start_fcp_op(struct nvme_fc_ctrl *ctrl, struct nvme_fc_queue *queue, · 51 unmodified lines | ||
| 2257 | 2254 | if (!(op->flags & FCOP_FLAGS_AEN)) |
| 2258 | 2255 | blk_mq_start_request(op->rq); |
| 2259 | 2256 | |
| 2257 | + cmdiu->csn = cpu_to_be32(atomic_inc_return(&queue->csn)); | |
| 2260 | 2258 | ret = ctrl->lport->ops->fcp_io(&ctrl->lport->localport, |
| 2261 | 2259 | &ctrl->rport->remoteport, |
| 2262 | 2260 | queue->lldd_handle, &op->fcp_req); |
| 2263 | 2261 | |
| 2264 | 2262 | if (ret) { |
| 2263 | + /* | |
| 2264 | + * If the lld fails to send the command is there an issue with | |
| 2265 | + * the csn value? If the command that fails is the Connect, | |
| 2266 | + * no - as the connection won't be live. If it is a command | |
| 2267 | + * post-connect, it's possible a gap in csn may be created. | |
| 2268 | + * Does this matter? As Linux initiators don't send fused | |
| 2269 | + * commands, no. The gap would exist, but as there's nothing | |
| 2270 | + * that depends on csn order to be delivered on the target | |
| 2271 | + * side, it shouldn't hurt. It would be difficult for a | |
| 2272 | + * target to even detect the csn gap as it has no idea when the | |
| 2273 | + * cmd with the csn was supposed to arrive. | |
| 2274 | + */ | |
| 2265 | 2275 | opstate = atomic_xchg(&op->state, FCPOP_STATE_COMPLETE); |
| 2266 | 2276 | __nvme_fc_fcpop_chk_teardowns(ctrl, op, opstate); |
| 2267 | 2277 | |
| @@ -24,6 +24,11 @@ u32 nvmet_get_log_page_len(struct nvme_command *cmd) · 23 unmodified lines | ||
| 24 | 24 | return len; |
| 25 | 25 | } |
| 26 | 26 | |
| 27 | +u64 nvmet_get_log_page_offset(struct nvme_command *cmd) | |
| 28 | +{ | |
| 29 | + return le64_to_cpu(cmd->get_log_page.lpo); | |
| 30 | +} | |
| 31 | + | |
| 27 | 32 | static void nvmet_execute_get_log_page_noop(struct nvmet_req *req) |
| 28 | 33 | { |
| 29 | 34 | nvmet_req_complete(req, nvmet_zero_sgl(req, 0, req->data_len)); |
| @@ -131,54 +131,76 @@ static void nvmet_set_disc_traddr(struct nvmet_req *req, struct nvmet_port *port · 130 unmodified lines | ||
| 131 | 131 | memcpy(traddr, port->disc_addr.traddr, NVMF_TRADDR_SIZE); |
| 132 | 132 | } |
| 133 | 133 | |
| 134 | +static size_t discovery_log_entries(struct nvmet_req *req) | |
| 135 | +{ | |
| 136 | + struct nvmet_ctrl *ctrl = req->sq->ctrl; | |
| 137 | + struct nvmet_subsys_link *p; | |
| 138 | + struct nvmet_port *r; | |
| 139 | + size_t entries = 0; | |
| 140 | + | |
| 141 | + list_for_each_entry(p, &req->port->subsystems, entry) { | |
| 142 | + if (!nvmet_host_allowed(p->subsys, ctrl->hostnqn)) | |
| 143 | + continue; | |
| 144 | + entries++; | |
| 145 | + } | |
| 146 | + list_for_each_entry(r, &req->port->referrals, entry) | |
| 147 | + entries++; | |
| 148 | + return entries; | |
| 149 | +} | |
| 150 | + | |
| 134 | 151 | static void nvmet_execute_get_disc_log_page(struct nvmet_req *req) |
| 135 | 152 | { |
| 136 | 153 | const int entry_size = sizeof(struct nvmf_disc_rsp_page_entry); |
| 137 | 154 | struct nvmet_ctrl *ctrl = req->sq->ctrl; |
| 138 | 155 | struct nvmf_disc_rsp_page_hdr *hdr; |
| 156 | + u64 offset = nvmet_get_log_page_offset(req->cmd); | |
| 139 | 157 | size_t data_len = nvmet_get_log_page_len(req->cmd); |
| 140 | − size_t alloc_len = max(data_len, sizeof(*hdr)); | |
| 141 | − int residual_len = data_len - sizeof(*hdr); | |
| 158 | + size_t alloc_len; | |
| 142 | 159 | struct nvmet_subsys_link *p; |
| 143 | 160 | struct nvmet_port *r; |
| 144 | 161 | u32 numrec = 0; |
| 145 | 162 | u16 status = 0; |
| 163 | + void *buffer; | |
| 164 | + | |
| 165 | + /* Spec requires dword aligned offsets */ | |
| 166 | + if (offset & 0x3) { | |
| 167 | + status = NVME_SC_INVALID_FIELD | NVME_SC_DNR; | |
| 168 | + goto out; | |
| 169 | + } | |
| 146 | 170 | |
| 147 | 171 | /* |
| 148 | 172 | * Make sure we're passing at least a buffer of response header size. |
| 149 | 173 | * If host provided data len is less than the header size, only the |
| 150 | 174 | * number of bytes requested by host will be sent to host. |
| 151 | 175 | */ |
| 152 | − hdr = kzalloc(alloc_len, GFP_KERNEL); | |
| 153 | − if (!hdr) { | |
| 176 | + down_read(&nvmet_config_sem); | |
| 177 | + alloc_len = sizeof(*hdr) + entry_size * discovery_log_entries(req); | |
| 178 | + buffer = kzalloc(alloc_len, GFP_KERNEL); | |
| 179 | + if (!buffer) { | |
| 180 | + up_read(&nvmet_config_sem); | |
| 154 | 181 | status = NVME_SC_INTERNAL; |
| 155 | 182 | goto out; |
| 156 | 183 | } |
| 157 | 184 | |
| 158 | − down_read(&nvmet_config_sem); | |
| 185 | + hdr = buffer; | |
| 159 | 186 | list_for_each_entry(p, &req->port->subsystems, entry) { |
| 187 | + char traddr[NVMF_TRADDR_SIZE]; | |
| 188 | + | |
| 160 | 189 | if (!nvmet_host_allowed(p->subsys, ctrl->hostnqn)) |
| 161 | 190 | continue; |
| 162 | − if (residual_len >= entry_size) { | |
| 163 | − char traddr[NVMF_TRADDR_SIZE]; | |
| 164 | − | |
| 165 | − nvmet_set_disc_traddr(req, req->port, traddr); | |
| 166 | − nvmet_format_discovery_entry(hdr, req->port, | |
| 167 | − p->subsys->subsysnqn, traddr, | |
| 168 | − NVME_NQN_NVME, numrec); | |
| 169 | − residual_len -= entry_size; | |
| 170 | − } | |
| 191 | + | |
| 192 | + nvmet_set_disc_traddr(req, req->port, traddr); | |
| 193 | + nvmet_format_discovery_entry(hdr, req->port, | |
| 194 | + p->subsys->subsysnqn, traddr, | |
| 195 | + NVME_NQN_NVME, numrec); | |
| 171 | 196 | numrec++; |
| 172 | 197 | } |
| 173 | 198 | |
| 174 | 199 | list_for_each_entry(r, &req->port->referrals, entry) { |
| 175 | − if (residual_len >= entry_size) { | |
| 176 | − nvmet_format_discovery_entry(hdr, r, | |
| 177 | − NVME_DISC_SUBSYS_NAME, | |
| 178 | − r->disc_addr.traddr, | |
| 179 | − NVME_NQN_DISC, numrec); | |
| 180 | − residual_len -= entry_size; | |
| 181 | − } | |
| 200 | + nvmet_format_discovery_entry(hdr, r, | |
| 201 | + NVME_DISC_SUBSYS_NAME, | |
| 202 | + r->disc_addr.traddr, | |
| 203 | + NVME_NQN_DISC, numrec); | |
| 182 | 204 | numrec++; |
| 183 | 205 | } |
| 184 | 206 | |
| @@ -190,8 +212,8 @@ static void nvmet_execute_get_disc_log_page(struct nvmet_req *req) · 5 unmodified lines | ||
| 190 | 212 | |
| 191 | 213 | up_read(&nvmet_config_sem); |
| 192 | 214 | |
| 193 | − status = nvmet_copy_to_sgl(req, 0, hdr, data_len); | |
| 194 | − kfree(hdr); | |
| 215 | + status = nvmet_copy_to_sgl(req, 0, buffer + offset, data_len); | |
| 216 | + kfree(buffer); | |
| 195 | 217 | out: |
| 196 | 218 | nvmet_req_complete(req, status); |
| 197 | 219 | } |
| @@ -428,6 +428,7 @@ u16 nvmet_copy_from_sgl(struct nvmet_req *req, off_t off, void *buf, · 427 unmodified lines | ||
| 428 | 428 | u16 nvmet_zero_sgl(struct nvmet_req *req, off_t off, size_t len); |
| 429 | 429 | |
| 430 | 430 | u32 nvmet_get_log_page_len(struct nvme_command *cmd); |
| 431 | +u64 nvmet_get_log_page_offset(struct nvme_command *cmd); | |
| 431 | 432 | |
| 432 | 433 | extern struct list_head *nvmet_ports; |
| 433 | 434 | void nvmet_port_disc_changed(struct nvmet_port *port, |
| @@ -115,6 +115,10 @@ static void remove_board(struct controller *ctrl, bool safe_removal) · 114 unmodified lines | ||
| 115 | 115 | * removed from the slot/adapter. |
| 116 | 116 | */ |
| 117 | 117 | msleep(1000); |
| 118 | + | |
| 119 | + /* Ignore link or presence changes caused by power off */ | |
| 120 | + atomic_and(~(PCI_EXP_SLTSTA_DLLSC | PCI_EXP_SLTSTA_PDC), | |
| 121 | + &ctrl->pending_events); | |
| 118 | 122 | } |
| 119 | 123 | |
| 120 | 124 | /* turn off Green LED */ |
| @@ -3877,6 +3877,8 @@ DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_MARVELL_EXT, 0x9128, · 3876 unmodified lines | ||
| 3877 | 3877 | /* https://bugzilla.kernel.org/show_bug.cgi?id=42679#c14 */ |
| 3878 | 3878 | DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_MARVELL_EXT, 0x9130, |
| 3879 | 3879 | quirk_dma_func1_alias); |
| 3880 | +DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_MARVELL_EXT, 0x9170, | |
| 3881 | + quirk_dma_func1_alias); | |
| 3880 | 3882 | /* https://bugzilla.kernel.org/show_bug.cgi?id=42679#c47 + c57 */ |
| 3881 | 3883 | DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_MARVELL_EXT, 0x9172, |
| 3882 | 3884 | quirk_dma_func1_alias); |
| @@ -17,6 +17,7 @@ · 16 unmodified lines | ||
| 17 | 17 | |
| 18 | 18 | #include <linux/debugfs.h> |
| 19 | 19 | #include <linux/device.h> |
| 20 | +#include <linux/dmi.h> | |
| 20 | 21 | #include <linux/init.h> |
| 21 | 22 | #include <linux/io.h> |
| 22 | 23 | #include <linux/platform_data/x86/clk-pmc-atom.h> |
| @@ -391,11 +392,27 @@ static int pmc_dbgfs_register(struct pmc_dev *pmc) · 368 unmodified lines | ||
| 391 | 392 | } |
| 392 | 393 | #endif /* CONFIG_DEBUG_FS */ |
| 393 | 394 | |
| 395 | +/* | |
| 396 | + * Some systems need one or more of their pmc_plt_clks to be | |
| 397 | + * marked as critical. | |
| 398 | + */ | |
| 399 | +static const struct dmi_system_id critclk_systems[] = { | |
| 400 | + { | |
| 401 | + .ident = "MPL CEC1x", | |
| 402 | + .matches = { | |
| 403 | + DMI_MATCH(DMI_SYS_VENDOR, "MPL AG"), | |
| 404 | + DMI_MATCH(DMI_PRODUCT_NAME, "CEC10 Family"), | |
| 405 | + }, | |
| 406 | + }, | |
| 407 | + { /*sentinel*/ } | |
| 408 | +}; | |
| 409 | + | |
| 394 | 410 | static int pmc_setup_clks(struct pci_dev *pdev, void __iomem *pmc_regmap, |
| 395 | 411 | const struct pmc_data *pmc_data) |
| 396 | 412 | { |
| 397 | 413 | struct platform_device *clkdev; |
| 398 | 414 | struct pmc_clk_data *clk_data; |
| 415 | + const struct dmi_system_id *d = dmi_first_match(critclk_systems); | |
| 399 | 416 | |
| 400 | 417 | clk_data = kzalloc(sizeof(*clk_data), GFP_KERNEL); |
| 401 | 418 | if (!clk_data) |
| @@ -403,6 +420,10 @@ static int pmc_setup_clks(struct pci_dev *pdev, void __iomem *pmc_regmap, · 1 unmodified line | ||
| 403 | 420 | |
| 404 | 421 | clk_data->base = pmc_regmap; /* offset is added by client */ |
| 405 | 422 | clk_data->clks = pmc_data->clks; |
| 423 | + if (d) { | |
| 424 | + clk_data->critical = true; | |
| 425 | + pr_info("%s critclks quirk enabled\n", d->ident); | |
| 426 | + } | |
| 406 | 427 | |
| 407 | 428 | clkdev = platform_device_register_data(&pdev->dev, "clk-pmc-atom", |
| 408 | 429 | PLATFORM_DEVID_NONE, |
| @@ -1713,8 +1713,11 @@ csio_scsi_err_handler(struct csio_hw *hw, struct csio_ioreq *req) · 1712 unmodified lines | ||
| 1713 | 1713 | } |
| 1714 | 1714 | |
| 1715 | 1715 | out: |
| 1716 | − if (req->nsge > 0) | |
| 1716 | + if (req->nsge > 0) { | |
| 1717 | 1717 | scsi_dma_unmap(cmnd); |
| 1718 | + if (req->dcopy && (host_status == DID_OK)) | |
| 1719 | + host_status = csio_scsi_copy_to_sgl(hw, req); | |
| 1720 | + } | |
| 1718 | 1721 | |
| 1719 | 1722 | cmnd->result = (((host_status) << 16) | scsi_status); |
| 1720 | 1723 | cmnd->scsi_done(cmnd); |
| @@ -793,6 +793,7 @@ static int virtscsi_probe(struct virtio_device *vdev) · 792 unmodified lines | ||
| 793 | 793 | |
| 794 | 794 | /* We need to know how many queues before we allocate. */ |
| 795 | 795 | num_queues = virtscsi_config_get(vdev, num_queues) ? : 1; |
| 796 | + num_queues = min_t(unsigned int, nr_cpu_ids, num_queues); | |
| 796 | 797 | |
| 797 | 798 | num_targets = virtscsi_config_get(vdev, max_target) + 1; |
| 798 | 799 | |
| @@ -911,8 +911,12 @@ static int vhost_new_umem_range(struct vhost_umem *umem, · 910 unmodified lines | ||
| 911 | 911 | u64 start, u64 size, u64 end, |
| 912 | 912 | u64 userspace_addr, int perm) |
| 913 | 913 | { |
| 914 | − struct vhost_umem_node *tmp, *node = kmalloc(sizeof(*node), GFP_ATOMIC); | |
| 914 | + struct vhost_umem_node *tmp, *node; | |
| 915 | 915 | |
| 916 | + if (!size) | |
| 917 | + return -EFAULT; | |
| 918 | + | |
| 919 | + node = kmalloc(sizeof(*node), GFP_ATOMIC); | |
| 916 | 920 | if (!node) |
| 917 | 921 | return -ENOMEM; |
| 918 | 922 | |
| @@ -255,9 +255,11 @@ void vp_del_vqs(struct virtio_device *vdev) · 254 unmodified lines | ||
| 255 | 255 | for (i = 0; i < vp_dev->msix_used_vectors; ++i) |
| 256 | 256 | free_irq(pci_irq_vector(vp_dev->pci_dev, i), vp_dev); |
| 257 | 257 | |
| 258 | − for (i = 0; i < vp_dev->msix_vectors; i++) | |
| 259 | − if (vp_dev->msix_affinity_masks[i]) | |
| 260 | − free_cpumask_var(vp_dev->msix_affinity_masks[i]); | |
| 258 | + if (vp_dev->msix_affinity_masks) { | |
| 259 | + for (i = 0; i < vp_dev->msix_vectors; i++) | |
| 260 | + if (vp_dev->msix_affinity_masks[i]) | |
| 261 | + free_cpumask_var(vp_dev->msix_affinity_masks[i]); | |
| 262 | + } | |
| 261 | 263 | |
| 262 | 264 | if (vp_dev->msix_enabled) { |
| 263 | 265 | /* Disable the vector used for configuration */ |
| @@ -882,6 +882,8 @@ static struct virtqueue *vring_create_virtqueue_split( · 881 unmodified lines | ||
| 882 | 882 | GFP_KERNEL|__GFP_NOWARN|__GFP_ZERO); |
| 883 | 883 | if (queue) |
| 884 | 884 | break; |
| 885 | + if (!may_reduce_num) | |
| 886 | + return NULL; | |
| 885 | 887 | } |
| 886 | 888 | |
| 887 | 889 | if (!num) |
| @@ -610,6 +610,7 @@ static long afs_wait_for_call_to_complete(struct afs_call *call, · 609 unmodified lines | ||
| 610 | 610 | bool stalled = false; |
| 611 | 611 | u64 rtt; |
| 612 | 612 | u32 life, last_life; |
| 613 | + bool rxrpc_complete = false; | |
| 613 | 614 | |
| 614 | 615 | DECLARE_WAITQUEUE(myself, current); |
| 615 | 616 | |
| @@ -621,7 +622,7 @@ static long afs_wait_for_call_to_complete(struct afs_call *call, · 5 unmodified lines | ||
| 621 | 622 | rtt2 = 2; |
| 622 | 623 | |
| 623 | 624 | timeout = rtt2; |
| 624 | − last_life = rxrpc_kernel_check_life(call->net->socket, call->rxcall); | |
| 625 | + rxrpc_kernel_check_life(call->net->socket, call->rxcall, &last_life); | |
| 625 | 626 | |
| 626 | 627 | add_wait_queue(&call->waitq, &myself); |
| 627 | 628 | for (;;) { |
| @@ -639,7 +640,12 @@ static long afs_wait_for_call_to_complete(struct afs_call *call, · 11 unmodified lines | ||
| 639 | 640 | if (afs_check_call_state(call, AFS_CALL_COMPLETE)) |
| 640 | 641 | break; |
| 641 | 642 | |
| 642 | − life = rxrpc_kernel_check_life(call->net->socket, call->rxcall); | |
| 643 | + if (!rxrpc_kernel_check_life(call->net->socket, call->rxcall, &life)) { | |
| 644 | + /* rxrpc terminated the call. */ | |
| 645 | + rxrpc_complete = true; | |
| 646 | + break; | |
| 647 | + } | |
| 648 | + | |
| 643 | 649 | if (timeout == 0 && |
| 644 | 650 | life == last_life && signal_pending(current)) { |
| 645 | 651 | if (stalled) |
| @@ -663,12 +669,16 @@ static long afs_wait_for_call_to_complete(struct afs_call *call, · 17 unmodified lines | ||
| 663 | 669 | remove_wait_queue(&call->waitq, &myself); |
| 664 | 670 | __set_current_state(TASK_RUNNING); |
| 665 | 671 | |
| 666 | − /* Kill off the call if it's still live. */ | |
| 667 | 672 | if (!afs_check_call_state(call, AFS_CALL_COMPLETE)) { |
| 668 | − _debug("call interrupted"); | |
| 669 | − if (rxrpc_kernel_abort_call(call->net->socket, call->rxcall, | |
| 670 | − RX_USER_ABORT, -EINTR, "KWI")) | |
| 671 | − afs_set_call_complete(call, -EINTR, 0); | |
| 673 | + if (rxrpc_complete) { | |
| 674 | + afs_set_call_complete(call, call->error, call->abort_code); | |
| 675 | + } else { | |
| 676 | + /* Kill off the call if it's still live. */ | |
| 677 | + _debug("call interrupted"); | |
| 678 | + if (rxrpc_kernel_abort_call(call->net->socket, call->rxcall, | |
| 679 | + RX_USER_ABORT, -EINTR, "KWI")) | |
| 680 | + afs_set_call_complete(call, -EINTR, 0); | |
| 681 | + } | |
| 672 | 682 | } |
| 673 | 683 | |
| 674 | 684 | spin_lock_bh(&call->state_lock); |
| @@ -1034,7 +1034,7 @@ static inline struct aio_kiocb *aio_get_req(struct kioctx *ctx) · 1033 unmodified lines | ||
| 1034 | 1034 | return NULL; |
| 1035 | 1035 | |
| 1036 | 1036 | if (unlikely(!get_reqs_available(ctx))) { |
| 1037 | − kfree(req); | |
| 1037 | + kmem_cache_free(kiocb_cachep, req); | |
| 1038 | 1038 | return NULL; |
| 1039 | 1039 | } |
| 1040 | 1040 | |
| @@ -1794,7 +1794,7 @@ static int __io_submit_one(struct kioctx *ctx, const struct iocb *iocb, · 753 unmodified lines | ||
| 1794 | 1794 | */ |
| 1795 | 1795 | eventfd = eventfd_ctx_fdget(iocb->aio_resfd); |
| 1796 | 1796 | if (IS_ERR(eventfd)) |
| 1797 | − return PTR_ERR(req->ki_eventfd); | |
| 1797 | + return PTR_ERR(eventfd); | |
| 1798 | 1798 | |
| 1799 | 1799 | req->ki_eventfd = eventfd; |
| 1800 | 1800 | } |
| @@ -307,10 +307,10 @@ static void blkdev_bio_end_io(struct bio *bio) · 306 unmodified lines | ||
| 307 | 307 | struct blkdev_dio *dio = bio->bi_private; |
| 308 | 308 | bool should_dirty = dio->should_dirty; |
| 309 | 309 | |
| 310 | − if (dio->multi_bio && !atomic_dec_and_test(&dio->ref)) { | |
| 311 | − if (bio->bi_status && !dio->bio.bi_status) | |
| 312 | − dio->bio.bi_status = bio->bi_status; | |
| 313 | − } else { | |
| 310 | + if (bio->bi_status && !dio->bio.bi_status) | |
| 311 | + dio->bio.bi_status = bio->bi_status; | |
| 312 | + | |
| 313 | + if (!dio->multi_bio || atomic_dec_and_test(&dio->ref)) { | |
| 314 | 314 | if (!dio->is_sync) { |
| 315 | 315 | struct kiocb *iocb = dio->iocb; |
| 316 | 316 | ssize_t ret; |
| @@ -501,6 +501,16 @@ static noinline int btrfs_ioctl_fitrim(struct file *file, void __user *arg) · 500 unmodified lines | ||
| 501 | 501 | if (!capable(CAP_SYS_ADMIN)) |
| 502 | 502 | return -EPERM; |
| 503 | 503 | |
| 504 | + /* | |
| 505 | + * If the fs is mounted with nologreplay, which requires it to be | |
| 506 | + * mounted in RO mode as well, we can not allow discard on free space | |
| 507 | + * inside block groups, because log trees refer to extents that are not | |
| 508 | + * pinned in a block group's free space cache (pinning the extents is | |
| 509 | + * precisely the first phase of replaying a log tree). | |
| 510 | + */ | |
| 511 | + if (btrfs_test_opt(fs_info, NOLOGREPLAY)) | |
| 512 | + return -EROFS; | |
| 513 | + | |
| 504 | 514 | rcu_read_lock(); |
| 505 | 515 | list_for_each_entry_rcu(device, &fs_info->fs_devices->devices, |
| 506 | 516 | dev_list) { |
| @@ -366,11 +366,11 @@ int btrfs_subvol_inherit_props(struct btrfs_trans_handle *trans, · 365 unmodified lines | ||
| 366 | 366 | |
| 367 | 367 | static int prop_compression_validate(const char *value, size_t len) |
| 368 | 368 | { |
| 369 | − if (!strncmp("lzo", value, len)) | |
| 369 | + if (!strncmp("lzo", value, 3)) | |
| 370 | 370 | return 0; |
| 371 | − else if (!strncmp("zlib", value, len)) | |
| 371 | + else if (!strncmp("zlib", value, 4)) | |
| 372 | 372 | return 0; |
| 373 | − else if (!strncmp("zstd", value, len)) | |
| 373 | + else if (!strncmp("zstd", value, 4)) | |
| 374 | 374 | return 0; |
| 375 | 375 | |
| 376 | 376 | return -EINVAL; |
| @@ -396,7 +396,7 @@ static int prop_compression_apply(struct inode *inode, · 19 unmodified lines | ||
| 396 | 396 | btrfs_set_fs_incompat(fs_info, COMPRESS_LZO); |
| 397 | 397 | } else if (!strncmp("zlib", value, 4)) { |
| 398 | 398 | type = BTRFS_COMPRESS_ZLIB; |
| 399 | − } else if (!strncmp("zstd", value, len)) { | |
| 399 | + } else if (!strncmp("zstd", value, 4)) { | |
| 400 | 400 | type = BTRFS_COMPRESS_ZSTD; |
| 401 | 401 | btrfs_set_fs_incompat(fs_info, COMPRESS_ZSTD); |
| 402 | 402 | } else { |
| @@ -33,6 +33,7 @@ · 32 unmodified lines | ||
| 33 | 33 | #include <linux/sizes.h> |
| 34 | 34 | #include <linux/mmu_notifier.h> |
| 35 | 35 | #include <linux/iomap.h> |
| 36 | +#include <asm/pgalloc.h> | |
| 36 | 37 | #include "internal.h" |
| 37 | 38 | |
| 38 | 39 | #define CREATE_TRACE_POINTS |
| @@ -1407,7 +1408,9 @@ static vm_fault_t dax_pmd_load_hole(struct xa_state *xas, struct vm_fault *vmf, · 1368 unmodified lines | ||
| 1407 | 1408 | { |
| 1408 | 1409 | struct address_space *mapping = vmf->vma->vm_file->f_mapping; |
| 1409 | 1410 | unsigned long pmd_addr = vmf->address & PMD_MASK; |
| 1411 | + struct vm_area_struct *vma = vmf->vma; | |
| 1410 | 1412 | struct inode *inode = mapping->host; |
| 1413 | + pgtable_t pgtable = NULL; | |
| 1411 | 1414 | struct page *zero_page; |
| 1412 | 1415 | spinlock_t *ptl; |
| 1413 | 1416 | pmd_t pmd_entry; |
| @@ -1422,12 +1425,22 @@ static vm_fault_t dax_pmd_load_hole(struct xa_state *xas, struct vm_fault *vmf, · 8 unmodified lines | ||
| 1422 | 1425 | *entry = dax_insert_entry(xas, mapping, vmf, *entry, pfn, |
| 1423 | 1426 | DAX_PMD | DAX_ZERO_PAGE, false); |
| 1424 | 1427 | |
| 1428 | + if (arch_needs_pgtable_deposit()) { | |
| 1429 | + pgtable = pte_alloc_one(vma->vm_mm); | |
| 1430 | + if (!pgtable) | |
| 1431 | + return VM_FAULT_OOM; | |
| 1432 | + } | |
| 1433 | + | |
| 1425 | 1434 | ptl = pmd_lock(vmf->vma->vm_mm, vmf->pmd); |
| 1426 | 1435 | if (!pmd_none(*(vmf->pmd))) { |
| 1427 | 1436 | spin_unlock(ptl); |
| 1428 | 1437 | goto fallback; |
| 1429 | 1438 | } |
| 1430 | 1439 | |
| 1440 | + if (pgtable) { | |
| 1441 | + pgtable_trans_huge_deposit(vma->vm_mm, vmf->pmd, pgtable); | |
| 1442 | + mm_inc_nr_ptes(vma->vm_mm); | |
| 1443 | + } | |
| 1431 | 1444 | pmd_entry = mk_pmd(zero_page, vmf->vma->vm_page_prot); |
| 1432 | 1445 | pmd_entry = pmd_mkhuge(pmd_entry); |
| 1433 | 1446 | set_pmd_at(vmf->vma->vm_mm, pmd_addr, vmf->pmd, pmd_entry); |
| @@ -1436,6 +1449,8 @@ static vm_fault_t dax_pmd_load_hole(struct xa_state *xas, struct vm_fault *vmf, · 2 unmodified lines | ||
| 1436 | 1449 | return VM_FAULT_NOPAGE; |
| 1437 | 1450 | |
| 1438 | 1451 | fallback: |
| 1452 | + if (pgtable) | |
| 1453 | + pte_free(vma->vm_mm, pgtable); | |
| 1439 | 1454 | trace_dax_pmd_load_hole_fallback(inode, vmf, zero_page, *entry); |
| 1440 | 1455 | return VM_FAULT_FALLBACK; |
| 1441 | 1456 | } |
| @@ -2056,10 +2056,8 @@ static ssize_t fuse_dev_splice_write(struct pipe_inode_info *pipe, · 2055 unmodified lines | ||
| 2056 | 2056 | rem += pipe->bufs[(pipe->curbuf + idx) & (pipe->buffers - 1)].len; |
| 2057 | 2057 | |
| 2058 | 2058 | ret = -EINVAL; |
| 2059 | − if (rem < len) { | |
| 2060 | − pipe_unlock(pipe); | |
| 2061 | − goto out; | |
| 2062 | − } | |
| 2059 | + if (rem < len) | |
| 2060 | + goto out_free; | |
| 2063 | 2061 | |
| 2064 | 2062 | rem = len; |
| 2065 | 2063 | while (rem) { |
| @@ -2077,7 +2075,9 @@ static ssize_t fuse_dev_splice_write(struct pipe_inode_info *pipe, · 11 unmodified lines | ||
| 2077 | 2075 | pipe->curbuf = (pipe->curbuf + 1) & (pipe->buffers - 1); |
| 2078 | 2076 | pipe->nrbufs--; |
| 2079 | 2077 | } else { |
| 2080 | − pipe_buf_get(pipe, ibuf); | |
| 2078 | + if (!pipe_buf_get(pipe, ibuf)) | |
| 2079 | + goto out_free; | |
| 2080 | + | |
| 2081 | 2081 | *obuf = *ibuf; |
| 2082 | 2082 | obuf->flags &= ~PIPE_BUF_FLAG_GIFT; |
| 2083 | 2083 | obuf->len = rem; |
| @@ -2100,11 +2100,11 @@ static ssize_t fuse_dev_splice_write(struct pipe_inode_info *pipe, · 16 unmodified lines | ||
| 2100 | 2100 | ret = fuse_dev_do_write(fud, &cs, len); |
| 2101 | 2101 | |
| 2102 | 2102 | pipe_lock(pipe); |
| 2103 | +out_free: | |
| 2103 | 2104 | for (idx = 0; idx < nbuf; idx++) |
| 2104 | 2105 | pipe_buf_release(pipe, &bufs[idx]); |
| 2105 | 2106 | pipe_unlock(pipe); |
| 2106 | 2107 | |
| 2107 | −out: | |
| 2108 | 2108 | kvfree(bufs); |
| 2109 | 2109 | return ret; |
| 2110 | 2110 | } |
| @@ -2245,6 +2245,10 @@ static int io_sq_offload_start(struct io_ring_ctx *ctx, · 2244 unmodified lines | ||
| 2245 | 2245 | goto err; |
| 2246 | 2246 | |
| 2247 | 2247 | if (ctx->flags & IORING_SETUP_SQPOLL) { |
| 2248 | + ret = -EPERM; | |
| 2249 | + if (!capable(CAP_SYS_ADMIN)) | |
| 2250 | + goto err; | |
| 2251 | + | |
| 2248 | 2252 | if (p->flags & IORING_SETUP_SQ_AFF) { |
| 2249 | 2253 | int cpu; |
| 2250 | 2254 | |
| @@ -329,9 +329,6 @@ ssize_t nfs42_proc_copy(struct file *src, loff_t pos_src, · 328 unmodified lines | ||
| 329 | 329 | }; |
| 330 | 330 | ssize_t err, err2; |
| 331 | 331 | |
| 332 | − if (!nfs_server_capable(file_inode(dst), NFS_CAP_COPY)) | |
| 333 | − return -EOPNOTSUPP; | |
| 334 | − | |
| 335 | 332 | src_lock = nfs_get_lock_context(nfs_file_open_context(src)); |
| 336 | 333 | if (IS_ERR(src_lock)) |
| 337 | 334 | return PTR_ERR(src_lock); |
| @@ -133,8 +133,10 @@ static ssize_t nfs4_copy_file_range(struct file *file_in, loff_t pos_in, · 132 unmodified lines | ||
| 133 | 133 | struct file *file_out, loff_t pos_out, |
| 134 | 134 | size_t count, unsigned int flags) |
| 135 | 135 | { |
| 136 | + if (!nfs_server_capable(file_inode(file_out), NFS_CAP_COPY)) | |
| 137 | + return -EOPNOTSUPP; | |
| 136 | 138 | if (file_inode(file_in) == file_inode(file_out)) |
| 137 | − return -EINVAL; | |
| 139 | + return -EOPNOTSUPP; | |
| 138 | 140 | return nfs42_proc_copy(file_in, pos_in, file_out, pos_out, count); |
| 139 | 141 | } |
| 140 | 142 | |
| @@ -2589,7 +2589,7 @@ static void nfs4_xdr_enc_getacl(struct rpc_rqst *req, struct xdr_stream *xdr, · 2588 unmodified lines | ||
| 2589 | 2589 | ARRAY_SIZE(nfs4_acl_bitmap), &hdr); |
| 2590 | 2590 | |
| 2591 | 2591 | rpc_prepare_reply_pages(req, args->acl_pages, 0, |
| 2592 | − args->acl_len, replen); | |
| 2592 | + args->acl_len, replen + 1); | |
| 2593 | 2593 | encode_nops(&hdr); |
| 2594 | 2594 | } |
| 2595 | 2595 | |
| @@ -2811,7 +2811,7 @@ static void nfs4_xdr_enc_fs_locations(struct rpc_rqst *req, · 215 unmodified lines | ||
| 2811 | 2811 | } |
| 2812 | 2812 | |
| 2813 | 2813 | rpc_prepare_reply_pages(req, (struct page **)&args->page, 0, |
| 2814 | − PAGE_SIZE, replen); | |
| 2814 | + PAGE_SIZE, replen + 1); | |
| 2815 | 2815 | encode_nops(&hdr); |
| 2816 | 2816 | } |
| 2817 | 2817 | |
| @@ -2041,7 +2041,8 @@ static int nfs23_validate_mount_data(void *options, · 2040 unmodified lines | ||
| 2041 | 2041 | memcpy(sap, &data->addr, sizeof(data->addr)); |
| 2042 | 2042 | args->nfs_server.addrlen = sizeof(data->addr); |
| 2043 | 2043 | args->nfs_server.port = ntohs(data->addr.sin_port); |
| 2044 | − if (!nfs_verify_server_address(sap)) | |
| 2044 | + if (sap->sa_family != AF_INET || | |
| 2045 | + !nfs_verify_server_address(sap)) | |
| 2045 | 2046 | goto out_no_address; |
| 2046 | 2047 | |
| 2047 | 2048 | if (!(data->flags & NFS_MOUNT_TCP)) |
| @@ -188,9 +188,9 @@ EXPORT_SYMBOL(generic_pipe_buf_steal); · 187 unmodified lines | ||
| 188 | 188 | * in the tee() system call, when we duplicate the buffers in one |
| 189 | 189 | * pipe into another. |
| 190 | 190 | */ |
| 191 | −void generic_pipe_buf_get(struct pipe_inode_info *pipe, struct pipe_buffer *buf) | |
| 191 | +bool generic_pipe_buf_get(struct pipe_inode_info *pipe, struct pipe_buffer *buf) | |
| 192 | 192 | { |
| 193 | − get_page(buf->page); | |
| 193 | + return try_get_page(buf->page); | |
| 194 | 194 | } |
| 195 | 195 | EXPORT_SYMBOL(generic_pipe_buf_get); |
| 196 | 196 | |
| @@ -1593,7 +1593,11 @@ retry: · 1592 unmodified lines | ||
| 1593 | 1593 | * Get a reference to this pipe buffer, |
| 1594 | 1594 | * so we can copy the contents over. |
| 1595 | 1595 | */ |
| 1596 | − pipe_buf_get(ipipe, ibuf); | |
| 1596 | + if (!pipe_buf_get(ipipe, ibuf)) { | |
| 1597 | + if (ret == 0) | |
| 1598 | + ret = -EFAULT; | |
| 1599 | + break; | |
| 1600 | + } | |
| 1597 | 1601 | *obuf = *ibuf; |
| 1598 | 1602 | |
| 1599 | 1603 | /* |
| @@ -1667,7 +1671,11 @@ static int link_pipe(struct pipe_inode_info *ipipe, · 67 unmodified lines | ||
| 1667 | 1671 | * Get a reference to this pipe buffer, |
| 1668 | 1672 | * so we can copy the contents over. |
| 1669 | 1673 | */ |
| 1670 | − pipe_buf_get(ipipe, ibuf); | |
| 1674 | + if (!pipe_buf_get(ipipe, ibuf)) { | |
| 1675 | + if (ret == 0) | |
| 1676 | + ret = -EFAULT; | |
| 1677 | + break; | |
| 1678 | + } | |
| 1671 | 1679 | |
| 1672 | 1680 | obuf = opipe->bufs + nbuf; |
| 1673 | 1681 | *obuf = *ibuf; |
| @@ -418,6 +418,8 @@ struct drm_crtc_helper_funcs { · 417 unmodified lines | ||
| 418 | 418 | * Drivers can use the @old_crtc_state input parameter if the operations |
| 419 | 419 | * needed to enable the CRTC don't depend solely on the new state but |
| 420 | 420 | * also on the transition between the old state and the new state. |
| 421 | + * | |
| 422 | + * This function is optional. | |
| 421 | 423 | */ |
| 422 | 424 | void (*atomic_enable)(struct drm_crtc *crtc, |
| 423 | 425 | struct drm_crtc_state *old_crtc_state); |
| @@ -441,6 +443,8 @@ struct drm_crtc_helper_funcs { · 17 unmodified lines | ||
| 441 | 443 | * parameter @old_crtc_state which could be used to access the old |
| 442 | 444 | * state. Atomic drivers should consider to use this one instead |
| 443 | 445 | * of @disable. |
| 446 | + * | |
| 447 | + * This function is optional. | |
| 444 | 448 | */ |
| 445 | 449 | void (*atomic_disable)(struct drm_crtc *crtc, |
| 446 | 450 | struct drm_crtc_state *old_crtc_state); |
| @@ -0,0 +1,18 @@ | ||
| 1 | +/* SPDX-License-Identifier: GPL-2.0 */ | |
| 2 | +/* | |
| 3 | + * Copyright (C) 2018-2019 SiFive, Inc. | |
| 4 | + * Wesley Terpstra | |
| 5 | + * Paul Walmsley | |
| 6 | + */ | |
| 7 | + | |
| 8 | +#ifndef __DT_BINDINGS_CLOCK_SIFIVE_FU540_PRCI_H | |
| 9 | +#define __DT_BINDINGS_CLOCK_SIFIVE_FU540_PRCI_H | |
| 10 | + | |
| 11 | +/* Clock indexes for use by Device Tree data and the PRCI driver */ | |
| 12 | + | |
| 13 | +#define PRCI_CLK_COREPLL 0 | |
| 14 | +#define PRCI_CLK_DDRPLL 1 | |
| 15 | +#define PRCI_CLK_GEMGXLPLL 2 | |
| 16 | +#define PRCI_CLK_TLCLK 3 | |
| 17 | + | |
| 18 | +#endif | |
| @@ -120,19 +120,23 @@ static inline bool bio_full(struct bio *bio) · 119 unmodified lines | ||
| 120 | 120 | return bio->bi_vcnt >= bio->bi_max_vecs; |
| 121 | 121 | } |
| 122 | 122 | |
| 123 | −#define mp_bvec_for_each_segment(bv, bvl, i, iter_all) \ | |
| 124 | − for (bv = bvec_init_iter_all(&iter_all); \ | |
| 125 | − (iter_all.done < (bvl)->bv_len) && \ | |
| 126 | − (mp_bvec_next_segment((bvl), &iter_all), 1); \ | |
| 127 | − iter_all.done += bv->bv_len, i += 1) | |
| 123 | +static inline bool bio_next_segment(const struct bio *bio, | |
| 124 | + struct bvec_iter_all *iter) | |
| 125 | +{ | |
| 126 | + if (iter->idx >= bio->bi_vcnt) | |
| 127 | + return false; | |
| 128 | + | |
| 129 | + bvec_advance(&bio->bi_io_vec[iter->idx], iter); | |
| 130 | + return true; | |
| 131 | +} | |
| 128 | 132 | |
| 129 | 133 | /* |
| 130 | 134 | * drivers should _never_ use the all version - the bio may have been split |
| 131 | 135 | * before it got to the driver and the driver won't own all of it |
| 132 | 136 | */ |
| 133 | −#define bio_for_each_segment_all(bvl, bio, i, iter_all) \ | |
| 134 | − for (i = 0, iter_all.idx = 0; iter_all.idx < (bio)->bi_vcnt; iter_all.idx++) \ | |
| 135 | − mp_bvec_for_each_segment(bvl, &((bio)->bi_io_vec[iter_all.idx]), i, iter_all) | |
| 137 | +#define bio_for_each_segment_all(bvl, bio, i, iter) \ | |
| 138 | + for (i = 0, bvl = bvec_init_iter_all(&iter); \ | |
| 139 | + bio_next_segment((bio), &iter); i++) | |
| 136 | 140 | |
| 137 | 141 | static inline void bio_advance_iter(struct bio *bio, struct bvec_iter *iter, |
| 138 | 142 | unsigned bytes) |
| @@ -302,6 +302,7 @@ void blk_mq_requeue_request(struct request *rq, bool kick_requeue_list); · 301 unmodified lines | ||
| 302 | 302 | void blk_mq_kick_requeue_list(struct request_queue *q); |
| 303 | 303 | void blk_mq_delay_kick_requeue_list(struct request_queue *q, unsigned long msecs); |
| 304 | 304 | bool blk_mq_complete_request(struct request *rq); |
| 305 | +void blk_mq_complete_request_sync(struct request *rq); | |
| 305 | 306 | bool blk_mq_bio_list_merge(struct request_queue *q, struct list_head *list, |
| 306 | 307 | struct bio *bio); |
| 307 | 308 | bool blk_mq_queue_stopped(struct request_queue *q); |
| @@ -145,18 +145,18 @@ static inline bool bvec_iter_advance(const struct bio_vec *bv, · 144 unmodified lines | ||
| 145 | 145 | |
| 146 | 146 | static inline struct bio_vec *bvec_init_iter_all(struct bvec_iter_all *iter_all) |
| 147 | 147 | { |
| 148 | − iter_all->bv.bv_page = NULL; | |
| 149 | 148 | iter_all->done = 0; |
| 149 | + iter_all->idx = 0; | |
| 150 | 150 | |
| 151 | 151 | return &iter_all->bv; |
| 152 | 152 | } |
| 153 | 153 | |
| 154 | −static inline void mp_bvec_next_segment(const struct bio_vec *bvec, | |
| 155 | − struct bvec_iter_all *iter_all) | |
| 154 | +static inline void bvec_advance(const struct bio_vec *bvec, | |
| 155 | + struct bvec_iter_all *iter_all) | |
| 156 | 156 | { |
| 157 | 157 | struct bio_vec *bv = &iter_all->bv; |
| 158 | 158 | |
| 159 | − if (bv->bv_page) { | |
| 159 | + if (iter_all->done) { | |
| 160 | 160 | bv->bv_page = nth_page(bv->bv_page, 1); |
| 161 | 161 | bv->bv_offset = 0; |
| 162 | 162 | } else { |
| @@ -165,6 +165,12 @@ static inline void mp_bvec_next_segment(const struct bio_vec *bvec, · 2 unmodified lines | ||
| 165 | 165 | } |
| 166 | 166 | bv->bv_len = min_t(unsigned int, PAGE_SIZE - bv->bv_offset, |
| 167 | 167 | bvec->bv_len - iter_all->done); |
| 168 | + iter_all->done += bv->bv_len; | |
| 169 | + | |
| 170 | + if (iter_all->done == bvec->bv_len) { | |
| 171 | + iter_all->idx++; | |
| 172 | + iter_all->done = 0; | |
| 173 | + } | |
| 168 | 174 | } |
| 169 | 175 | |
| 170 | 176 | /* |
| @@ -47,8 +47,8 @@ · 46 unmodified lines | ||
| 47 | 47 | |
| 48 | 48 | #define u64_to_user_ptr(x) ( \ |
| 49 | 49 | { \ |
| 50 | − typecheck(u64, x); \ | |
| 51 | − (void __user *)(uintptr_t)x; \ | |
| 50 | + typecheck(u64, (x)); \ | |
| 51 | + (void __user *)(uintptr_t)(x); \ | |
| 52 | 52 | } \ |
| 53 | 53 | ) |
| 54 | 54 | |
| @@ -28,6 +28,7 @@ · 27 unmodified lines | ||
| 28 | 28 | #include <linux/irqbypass.h> |
| 29 | 29 | #include <linux/swait.h> |
| 30 | 30 | #include <linux/refcount.h> |
| 31 | +#include <linux/nospec.h> | |
| 31 | 32 | #include <asm/signal.h> |
| 32 | 33 | |
| 33 | 34 | #include <linux/kvm.h> |
| @@ -513,10 +514,10 @@ static inline struct kvm_io_bus *kvm_get_bus(struct kvm *kvm, enum kvm_bus idx) · 479 unmodified lines | ||
| 513 | 514 | |
| 514 | 515 | static inline struct kvm_vcpu *kvm_get_vcpu(struct kvm *kvm, int i) |
| 515 | 516 | { |
| 516 | − /* Pairs with smp_wmb() in kvm_vm_ioctl_create_vcpu, in case | |
| 517 | − * the caller has read kvm->online_vcpus before (as is the case | |
| 518 | − * for kvm_for_each_vcpu, for example). | |
| 519 | − */ | |
| 517 | + int num_vcpus = atomic_read(&kvm->online_vcpus); | |
| 518 | + i = array_index_nospec(i, num_vcpus); | |
| 519 | + | |
| 520 | + /* Pairs with smp_wmb() in kvm_vm_ioctl_create_vcpu. */ | |
| 520 | 521 | smp_rmb(); |
| 521 | 522 | return kvm->vcpus[i]; |
| 522 | 523 | } |
| @@ -600,6 +601,7 @@ void kvm_put_kvm(struct kvm *kvm); · 77 unmodified lines | ||
| 600 | 601 | |
| 601 | 602 | static inline struct kvm_memslots *__kvm_memslots(struct kvm *kvm, int as_id) |
| 602 | 603 | { |
| 604 | + as_id = array_index_nospec(as_id, KVM_ADDRESS_SPACE_NUM); | |
| 603 | 605 | return srcu_dereference_check(kvm->memslots[as_id], &kvm->srcu, |
| 604 | 606 | lockdep_is_held(&kvm->slots_lock) || |
| 605 | 607 | !refcount_read(&kvm->users_count)); |
| @@ -966,6 +966,10 @@ static inline bool is_pci_p2pdma_page(const struct page *page) · 965 unmodified lines | ||
| 966 | 966 | } |
| 967 | 967 | #endif /* CONFIG_DEV_PAGEMAP_OPS */ |
| 968 | 968 | |
| 969 | +/* 127: arbitrary random number, small enough to assemble well */ | |
| 970 | +#define page_ref_zero_or_close_to_overflow(page) \ | |
| 971 | + ((unsigned int) page_ref_count(page) + 127u <= 127u) | |
| 972 | + | |
| 969 | 973 | static inline void get_page(struct page *page) |
| 970 | 974 | { |
| 971 | 975 | page = compound_head(page); |
| @@ -973,8 +977,17 @@ static inline void get_page(struct page *page) · 1 unmodified line | ||
| 973 | 977 | * Getting a normal page or the head of a compound page |
| 974 | 978 | * requires to already have an elevated page->_refcount. |
| 975 | 979 | */ |
| 976 | − VM_BUG_ON_PAGE(page_ref_count(page) <= 0, page); | |
| 980 | + VM_BUG_ON_PAGE(page_ref_zero_or_close_to_overflow(page), page); | |
| 981 | + page_ref_inc(page); | |
| 982 | +} | |
| 983 | + | |
| 984 | +static inline __must_check bool try_get_page(struct page *page) | |
| 985 | +{ | |
| 986 | + page = compound_head(page); | |
| 987 | + if (WARN_ON_ONCE(page_ref_count(page) <= 0)) | |
| 988 | + return false; | |
| 977 | 989 | page_ref_inc(page); |
| 990 | + return true; | |
| 978 | 991 | } |
| 979 | 992 | |
| 980 | 993 | static inline void put_page(struct page *page) |
| @@ -1498,6 +1498,7 @@ struct net_device_ops { · 1497 unmodified lines | ||
| 1498 | 1498 | * @IFF_FAILOVER: device is a failover master device |
| 1499 | 1499 | * @IFF_FAILOVER_SLAVE: device is lower dev of a failover master device |
| 1500 | 1500 | * @IFF_L3MDEV_RX_HANDLER: only invoke the rx handler of L3 master device |
| 1501 | + * @IFF_LIVE_RENAME_OK: rename is allowed while device is up and running | |
| 1501 | 1502 | */ |
| 1502 | 1503 | enum netdev_priv_flags { |
| 1503 | 1504 | IFF_802_1Q_VLAN = 1<<0, |
| @@ -1530,6 +1531,7 @@ enum netdev_priv_flags { · 26 unmodified lines | ||
| 1530 | 1531 | IFF_FAILOVER = 1<<27, |
| 1531 | 1532 | IFF_FAILOVER_SLAVE = 1<<28, |
| 1532 | 1533 | IFF_L3MDEV_RX_HANDLER = 1<<29, |
| 1534 | + IFF_LIVE_RENAME_OK = 1<<30, | |
| 1533 | 1535 | }; |
| 1534 | 1536 | |
| 1535 | 1537 | #define IFF_802_1Q_VLAN IFF_802_1Q_VLAN |
| @@ -1561,6 +1563,7 @@ enum netdev_priv_flags { · 25 unmodified lines | ||
| 1561 | 1563 | #define IFF_FAILOVER IFF_FAILOVER |
| 1562 | 1564 | #define IFF_FAILOVER_SLAVE IFF_FAILOVER_SLAVE |
| 1563 | 1565 | #define IFF_L3MDEV_RX_HANDLER IFF_L3MDEV_RX_HANDLER |
| 1566 | +#define IFF_LIVE_RENAME_OK IFF_LIVE_RENAME_OK | |
| 1564 | 1567 | |
| 1565 | 1568 | /** |
| 1566 | 1569 | * struct net_device - The DEVICE structure. |
| @@ -967,8 +967,13 @@ struct nvme_get_log_page_command { · 966 unmodified lines | ||
| 967 | 967 | __le16 numdl; |
| 968 | 968 | __le16 numdu; |
| 969 | 969 | __u16 rsvd11; |
| 970 | − __le32 lpol; | |
| 971 | − __le32 lpou; | |
| 970 | + union { | |
| 971 | + struct { | |
| 972 | + __le32 lpol; | |
| 973 | + __le32 lpou; | |
| 974 | + }; | |
| 975 | + __le64 lpo; | |
| 976 | + }; | |
| 972 | 977 | __u32 rsvd14[2]; |
| 973 | 978 | }; |
| 974 | 979 | |
| @@ -101,18 +101,20 @@ struct pipe_buf_operations { · 100 unmodified lines | ||
| 101 | 101 | /* |
| 102 | 102 | * Get a reference to the pipe buffer. |
| 103 | 103 | */ |
| 104 | − void (*get)(struct pipe_inode_info *, struct pipe_buffer *); | |
| 104 | + bool (*get)(struct pipe_inode_info *, struct pipe_buffer *); | |
| 105 | 105 | }; |
| 106 | 106 | |
| 107 | 107 | /** |
| 108 | 108 | * pipe_buf_get - get a reference to a pipe_buffer |
| 109 | 109 | * @pipe: the pipe that the buffer belongs to |
| 110 | 110 | * @buf: the buffer to get a reference to |
| 111 | + * | |
| 112 | + * Return: %true if the reference was successfully obtained. | |
| 111 | 113 | */ |
| 112 | −static inline void pipe_buf_get(struct pipe_inode_info *pipe, | |
| 114 | +static inline __must_check bool pipe_buf_get(struct pipe_inode_info *pipe, | |
| 113 | 115 | struct pipe_buffer *buf) |
| 114 | 116 | { |
| 115 | − buf->ops->get(pipe, buf); | |
| 117 | + return buf->ops->get(pipe, buf); | |
| 116 | 118 | } |
| 117 | 119 | |
| 118 | 120 | /** |
| @@ -171,7 +173,7 @@ struct pipe_inode_info *alloc_pipe_info(void); · 52 unmodified lines | ||
| 171 | 173 | void free_pipe_info(struct pipe_inode_info *); |
| 172 | 174 | |
| 173 | 175 | /* Generic pipe buffer ops functions */ |
| 174 | −void generic_pipe_buf_get(struct pipe_inode_info *, struct pipe_buffer *); | |
| 176 | +bool generic_pipe_buf_get(struct pipe_inode_info *, struct pipe_buffer *); | |
| 175 | 177 | int generic_pipe_buf_confirm(struct pipe_inode_info *, struct pipe_buffer *); |
| 176 | 178 | int generic_pipe_buf_steal(struct pipe_inode_info *, struct pipe_buffer *); |
| 177 | 179 | void generic_pipe_buf_release(struct pipe_inode_info *, struct pipe_buffer *); |
| @@ -35,10 +35,13 @@ struct pmc_clk { · 34 unmodified lines | ||
| 35 | 35 | * |
| 36 | 36 | * @base: PMC clock register base offset |
| 37 | 37 | * @clks: pointer to set of registered clocks, typically 0..5 |
| 38 | + * @critical: flag to indicate if firmware enabled pmc_plt_clks | |
| 39 | + * should be marked as critial or not | |
| 38 | 40 | */ |
| 39 | 41 | struct pmc_clk_data { |
| 40 | 42 | void __iomem *base; |
| 41 | 43 | const struct pmc_clk *clks; |
| 44 | + bool critical; | |
| 42 | 45 | }; |
| 43 | 46 | |
| 44 | 47 | #endif /* __PLATFORM_DATA_X86_CLK_PMC_ATOM_H */ |
| @@ -304,12 +304,4 @@ rpc_clnt_swap_deactivate(struct rpc_clnt *clnt) · 303 unmodified lines | ||
| 304 | 304 | } |
| 305 | 305 | #endif /* CONFIG_SUNRPC_SWAP */ |
| 306 | 306 | |
| 307 | −static inline bool | |
| 308 | −rpc_task_need_resched(const struct rpc_task *task) | |
| 309 | −{ | |
| 310 | − if (RPC_IS_QUEUED(task) || task->tk_callback) | |
| 311 | − return true; | |
| 312 | − return false; | |
| 313 | −} | |
| 314 | − | |
| 315 | 307 | #endif /* _LINUX_SUNRPC_SCHED_H_ */ |
| @@ -63,7 +63,7 @@ struct virtqueue; · 62 unmodified lines | ||
| 63 | 63 | /* |
| 64 | 64 | * Creates a virtqueue and allocates the descriptor ring. If |
| 65 | 65 | * may_reduce_num is set, then this may allocate a smaller ring than |
| 66 | − * expected. The caller should query virtqueue_get_ring_size to learn | |
| 66 | + * expected. The caller should query virtqueue_get_vring_size to learn | |
| 67 | 67 | * the actual size of the ring. |
| 68 | 68 | */ |
| 69 | 69 | struct virtqueue *vring_create_virtqueue(unsigned int index, |
| @@ -61,10 +61,12 @@ int rxrpc_kernel_charge_accept(struct socket *, rxrpc_notify_rx_t, · 60 unmodified lines | ||
| 61 | 61 | rxrpc_user_attach_call_t, unsigned long, gfp_t, |
| 62 | 62 | unsigned int); |
| 63 | 63 | void rxrpc_kernel_set_tx_length(struct socket *, struct rxrpc_call *, s64); |
| 64 | −u32 rxrpc_kernel_check_life(const struct socket *, const struct rxrpc_call *); | |
| 64 | +bool rxrpc_kernel_check_life(const struct socket *, const struct rxrpc_call *, | |
| 65 | + u32 *); | |
| 65 | 66 | void rxrpc_kernel_probe_life(struct socket *, struct rxrpc_call *); |
| 66 | 67 | u32 rxrpc_kernel_get_epoch(struct socket *, struct rxrpc_call *); |
| 67 | 68 | bool rxrpc_kernel_get_reply_time(struct socket *, struct rxrpc_call *, |
| 68 | 69 | ktime_t *); |
| 70 | +bool rxrpc_kernel_call_is_complete(struct rxrpc_call *); | |
| 69 | 71 | |
| 70 | 72 | #endif /* _NET_RXRPC_H */ |
| @@ -7183,6 +7183,11 @@ void cfg80211_pmsr_complete(struct wireless_dev *wdev, · 7182 unmodified lines | ||
| 7183 | 7183 | #define wiphy_info(wiphy, format, args...) \ |
| 7184 | 7184 | dev_info(&(wiphy)->dev, format, ##args) |
| 7185 | 7185 | |
| 7186 | +#define wiphy_err_ratelimited(wiphy, format, args...) \ | |
| 7187 | + dev_err_ratelimited(&(wiphy)->dev, format, ##args) | |
| 7188 | +#define wiphy_warn_ratelimited(wiphy, format, args...) \ | |
| 7189 | + dev_warn_ratelimited(&(wiphy)->dev, format, ##args) | |
| 7190 | + | |
| 7186 | 7191 | #define wiphy_debug(wiphy, format, args...) \ |
| 7187 | 7192 | wiphy_printk(KERN_DEBUG, wiphy, format, ##args) |
| 7188 | 7193 | |
| @@ -6231,8 +6231,6 @@ struct sk_buff *ieee80211_tx_dequeue(struct ieee80211_hw *hw, · 6230 unmodified lines | ||
| 6231 | 6231 | * @hw: pointer as obtained from ieee80211_alloc_hw() |
| 6232 | 6232 | * @ac: AC number to return packets from. |
| 6233 | 6233 | * |
| 6234 | − * Should only be called between calls to ieee80211_txq_schedule_start() | |
| 6235 | − * and ieee80211_txq_schedule_end(). | |
| 6236 | 6234 | * Returns the next txq if successful, %NULL if no queue is eligible. If a txq |
| 6237 | 6235 | * is returned, it should be returned with ieee80211_return_txq() after the |
| 6238 | 6236 | * driver has finished scheduling it. |
| @@ -6240,51 +6238,58 @@ struct sk_buff *ieee80211_tx_dequeue(struct ieee80211_hw *hw, · 1 unmodified line | ||
| 6240 | 6238 | struct ieee80211_txq *ieee80211_next_txq(struct ieee80211_hw *hw, u8 ac); |
| 6241 | 6239 | |
| 6242 | 6240 | /** |
| 6243 | − * ieee80211_return_txq - return a TXQ previously acquired by ieee80211_next_txq() | |
| 6244 | − * | |
| 6245 | − * @hw: pointer as obtained from ieee80211_alloc_hw() | |
| 6246 | − * @txq: pointer obtained from station or virtual interface | |
| 6247 | − * | |
| 6248 | − * Should only be called between calls to ieee80211_txq_schedule_start() | |
| 6249 | − * and ieee80211_txq_schedule_end(). | |
| 6250 | − */ | |
| 6251 | −void ieee80211_return_txq(struct ieee80211_hw *hw, struct ieee80211_txq *txq); | |
| 6252 | − | |
| 6253 | −/** | |
| 6254 | − * ieee80211_txq_schedule_start - acquire locks for safe scheduling of an AC | |
| 6241 | + * ieee80211_txq_schedule_start - start new scheduling round for TXQs | |
| 6255 | 6242 | * |
| 6256 | 6243 | * @hw: pointer as obtained from ieee80211_alloc_hw() |
| 6257 | 6244 | * @ac: AC number to acquire locks for |
| 6258 | 6245 | * |
| 6259 | − * Acquire locks needed to schedule TXQs from the given AC. Should be called | |
| 6260 | − * before ieee80211_next_txq() or ieee80211_return_txq(). | |
| 6246 | + * Should be called before ieee80211_next_txq() or ieee80211_return_txq(). | |
| 6247 | + * The driver must not call multiple TXQ scheduling rounds concurrently. | |
| 6261 | 6248 | */ |
| 6262 | −void ieee80211_txq_schedule_start(struct ieee80211_hw *hw, u8 ac) | |
| 6263 | − __acquires(txq_lock); | |
| 6249 | +void ieee80211_txq_schedule_start(struct ieee80211_hw *hw, u8 ac); | |
| 6250 | + | |
| 6251 | +/* (deprecated) */ | |
| 6252 | +static inline void ieee80211_txq_schedule_end(struct ieee80211_hw *hw, u8 ac) | |
| 6253 | +{ | |
| 6254 | +} | |
| 6255 | + | |
| 6256 | +void __ieee80211_schedule_txq(struct ieee80211_hw *hw, | |
| 6257 | + struct ieee80211_txq *txq, bool force); | |
| 6264 | 6258 | |
| 6265 | 6259 | /** |
| 6266 | − * ieee80211_txq_schedule_end - release locks for safe scheduling of an AC | |
| 6260 | + * ieee80211_schedule_txq - schedule a TXQ for transmission | |
| 6267 | 6261 | * |
| 6268 | 6262 | * @hw: pointer as obtained from ieee80211_alloc_hw() |
| 6269 | − * @ac: AC number to acquire locks for | |
| 6263 | + * @txq: pointer obtained from station or virtual interface | |
| 6270 | 6264 | * |
| 6271 | − * Release locks previously acquired by ieee80211_txq_schedule_end(). | |
| 6265 | + * Schedules a TXQ for transmission if it is not already scheduled, | |
| 6266 | + * even if mac80211 does not have any packets buffered. | |
| 6267 | + * | |
| 6268 | + * The driver may call this function if it has buffered packets for | |
| 6269 | + * this TXQ internally. | |
| 6272 | 6270 | */ |
| 6273 | −void ieee80211_txq_schedule_end(struct ieee80211_hw *hw, u8 ac) | |
| 6274 | − __releases(txq_lock); | |
| 6271 | +static inline void | |
| 6272 | +ieee80211_schedule_txq(struct ieee80211_hw *hw, struct ieee80211_txq *txq) | |
| 6273 | +{ | |
| 6274 | + __ieee80211_schedule_txq(hw, txq, true); | |
| 6275 | +} | |
| 6275 | 6276 | |
| 6276 | 6277 | /** |
| 6277 | − * ieee80211_schedule_txq - schedule a TXQ for transmission | |
| 6278 | + * ieee80211_return_txq - return a TXQ previously acquired by ieee80211_next_txq() | |
| 6278 | 6279 | * |
| 6279 | 6280 | * @hw: pointer as obtained from ieee80211_alloc_hw() |
| 6280 | 6281 | * @txq: pointer obtained from station or virtual interface |
| 6282 | + * @force: schedule txq even if mac80211 does not have any buffered packets. | |
| 6281 | 6283 | * |
| 6282 | − * Schedules a TXQ for transmission if it is not already scheduled. Takes a | |
| 6283 | − * lock, which means it must *not* be called between | |
| 6284 | − * ieee80211_txq_schedule_start() and ieee80211_txq_schedule_end() | |
| 6284 | + * The driver may set force=true if it has buffered packets for this TXQ | |
| 6285 | + * internally. | |
| 6285 | 6286 | */ |
| 6286 | −void ieee80211_schedule_txq(struct ieee80211_hw *hw, struct ieee80211_txq *txq) | |
| 6287 | − __acquires(txq_lock) __releases(txq_lock); | |
| 6287 | +static inline void | |
| 6288 | +ieee80211_return_txq(struct ieee80211_hw *hw, struct ieee80211_txq *txq, | |
| 6289 | + bool force) | |
| 6290 | +{ | |
| 6291 | + __ieee80211_schedule_txq(hw, txq, force); | |
| 6292 | +} | |
| 6288 | 6293 | |
| 6289 | 6294 | /** |
| 6290 | 6295 | * ieee80211_txq_may_transmit - check whether TXQ is allowed to transmit |
| @@ -266,7 +266,7 @@ void nr_stop_idletimer(struct sock *); · 265 unmodified lines | ||
| 266 | 266 | int nr_t1timer_running(struct sock *); |
| 267 | 267 | |
| 268 | 268 | /* sysctl_net_netrom.c */ |
| 269 | −void nr_register_sysctl(void); | |
| 269 | +int nr_register_sysctl(void); | |
| 270 | 270 | void nr_unregister_sysctl(void); |
| 271 | 271 | |
| 272 | 272 | #endif |
| @@ -2091,12 +2091,6 @@ static inline bool skwq_has_sleeper(struct socket_wq *wq) · 2090 unmodified lines | ||
| 2091 | 2091 | * @p: poll_table |
| 2092 | 2092 | * |
| 2093 | 2093 | * See the comments in the wq_has_sleeper function. |
| 2094 | − * | |
| 2095 | − * Do not derive sock from filp->private_data here. An SMC socket establishes | |
| 2096 | − * an internal TCP socket that is used in the fallback case. All socket | |
| 2097 | − * operations on the SMC socket are then forwarded to the TCP socket. In case of | |
| 2098 | − * poll, the filp->private_data pointer references the SMC socket because the | |
| 2099 | − * TCP socket has no file assigned. | |
| 2100 | 2094 | */ |
| 2101 | 2095 | static inline void sock_poll_wait(struct file *filp, struct socket *sock, |
| 2102 | 2096 | poll_table *p) |
| @@ -318,6 +318,7 @@ int tls_device_sendmsg(struct sock *sk, struct msghdr *msg, size_t size); · 317 unmodified lines | ||
| 318 | 318 | int tls_device_sendpage(struct sock *sk, struct page *page, |
| 319 | 319 | int offset, size_t size, int flags); |
| 320 | 320 | void tls_device_sk_destruct(struct sock *sk); |
| 321 | +void tls_device_free_resources_tx(struct sock *sk); | |
| 321 | 322 | void tls_device_init(void); |
| 322 | 323 | void tls_device_cleanup(void); |
| 323 | 324 | int tls_tx_records(struct sock *sk, int flags); |
| @@ -341,6 +342,7 @@ int tls_push_sg(struct sock *sk, struct tls_context *ctx, · 17 unmodified lines | ||
| 341 | 342 | int flags); |
| 342 | 343 | int tls_push_partial_record(struct sock *sk, struct tls_context *ctx, |
| 343 | 344 | int flags); |
| 345 | +bool tls_free_partial_record(struct sock *sk, struct tls_context *ctx); | |
| 344 | 346 | |
| 345 | 347 | static inline struct tls_msg *tls_msg(struct sk_buff *skb) |
| 346 | 348 | { |
| @@ -390,7 +392,7 @@ tls_validate_xmit_skb(struct sock *sk, struct net_device *dev, · 43 unmodified lines | ||
| 390 | 392 | static inline bool tls_is_sk_tx_device_offloaded(struct sock *sk) |
| 391 | 393 | { |
| 392 | 394 | #ifdef CONFIG_SOCK_VALIDATE_XMIT |
| 393 | − return sk_fullsock(sk) & | |
| 395 | + return sk_fullsock(sk) && | |
| 394 | 396 | (smp_load_acquire(&sk->sk_validate_xmit_skb) == |
| 395 | 397 | &tls_validate_xmit_skb); |
| 396 | 398 | #else |
| @@ -802,8 +802,13 @@ struct snd_soc_component_driver { · 801 unmodified lines | ||
| 802 | 802 | int probe_order; |
| 803 | 803 | int remove_order; |
| 804 | 804 | |
| 805 | − /* signal if the module handling the component cannot be removed */ | |
| 806 | − unsigned int ignore_module_refcount:1; | |
| 805 | + /* | |
| 806 | + * signal if the module handling the component should not be removed | |
| 807 | + * if a pcm is open. Setting this would prevent the module | |
| 808 | + * refcount being incremented in probe() but allow it be incremented | |
| 809 | + * when a pcm is opened and decremented when it is closed. | |
| 810 | + */ | |
| 811 | + unsigned int module_get_upon_open:1; | |
| 807 | 812 | |
| 808 | 813 | /* bits */ |
| 809 | 814 | unsigned int idle_bias_on:1; |
| @@ -1083,6 +1088,8 @@ struct snd_soc_card { · 273 unmodified lines | ||
| 1083 | 1088 | struct mutex mutex; |
| 1084 | 1089 | struct mutex dapm_mutex; |
| 1085 | 1090 | |
| 1091 | + spinlock_t dpcm_lock; | |
| 1092 | + | |
| 1086 | 1093 | bool instantiated; |
| 1087 | 1094 | bool topology_shortname_created; |
| 1088 | 1095 | |
| @@ -32,6 +32,7 @@ · 31 unmodified lines | ||
| 32 | 32 | |
| 33 | 33 | #ifndef __KERNEL__ |
| 34 | 34 | #include <stdlib.h> |
| 35 | +#include <time.h> | |
| 35 | 36 | #endif |
| 36 | 37 | |
| 37 | 38 | /* |
| @@ -706,7 +706,7 @@ static struct dma_debug_entry *dma_entry_alloc(void) · 705 unmodified lines | ||
| 706 | 706 | #ifdef CONFIG_STACKTRACE |
| 707 | 707 | entry->stacktrace.max_entries = DMA_DEBUG_STACKTRACE_ENTRIES; |
| 708 | 708 | entry->stacktrace.entries = entry->st_entries; |
| 709 | − entry->stacktrace.skip = 2; | |
| 709 | + entry->stacktrace.skip = 1; | |
| 710 | 710 | save_stack_trace(&entry->stacktrace); |
| 711 | 711 | #endif |
| 712 | 712 | |
| @@ -2009,8 +2009,8 @@ event_sched_out(struct perf_event *event, · 2008 unmodified lines | ||
| 2009 | 2009 | event->pmu->del(event, 0); |
| 2010 | 2010 | event->oncpu = -1; |
| 2011 | 2011 | |
| 2012 | − if (event->pending_disable) { | |
| 2013 | − event->pending_disable = 0; | |
| 2012 | + if (READ_ONCE(event->pending_disable) >= 0) { | |
| 2013 | + WRITE_ONCE(event->pending_disable, -1); | |
| 2014 | 2014 | state = PERF_EVENT_STATE_OFF; |
| 2015 | 2015 | } |
| 2016 | 2016 | perf_event_set_state(event, state); |
| @@ -2198,7 +2198,8 @@ EXPORT_SYMBOL_GPL(perf_event_disable); · 181 unmodified lines | ||
| 2198 | 2198 | |
| 2199 | 2199 | void perf_event_disable_inatomic(struct perf_event *event) |
| 2200 | 2200 | { |
| 2201 | − event->pending_disable = 1; | |
| 2201 | + WRITE_ONCE(event->pending_disable, smp_processor_id()); | |
| 2202 | + /* can fail, see perf_pending_event_disable() */ | |
| 2202 | 2203 | irq_work_queue(&event->pending); |
| 2203 | 2204 | } |
| 2204 | 2205 | |
| @@ -5810,10 +5811,45 @@ void perf_event_wakeup(struct perf_event *event) · 3605 unmodified lines | ||
| 5810 | 5811 | } |
| 5811 | 5812 | } |
| 5812 | 5813 | |
| 5814 | +static void perf_pending_event_disable(struct perf_event *event) | |
| 5815 | +{ | |
| 5816 | + int cpu = READ_ONCE(event->pending_disable); | |
| 5817 | + | |
| 5818 | + if (cpu < 0) | |
| 5819 | + return; | |
| 5820 | + | |
| 5821 | + if (cpu == smp_processor_id()) { | |
| 5822 | + WRITE_ONCE(event->pending_disable, -1); | |
| 5823 | + perf_event_disable_local(event); | |
| 5824 | + return; | |
| 5825 | + } | |
| 5826 | + | |
| 5827 | + /* | |
| 5828 | + * CPU-A CPU-B | |
| 5829 | + * | |
| 5830 | + * perf_event_disable_inatomic() | |
| 5831 | + * @pending_disable = CPU-A; | |
| 5832 | + * irq_work_queue(); | |
| 5833 | + * | |
| 5834 | + * sched-out | |
| 5835 | + * @pending_disable = -1; | |
| 5836 | + * | |
| 5837 | + * sched-in | |
| 5838 | + * perf_event_disable_inatomic() | |
| 5839 | + * @pending_disable = CPU-B; | |
| 5840 | + * irq_work_queue(); // FAILS | |
| 5841 | + * | |
| 5842 | + * irq_work_run() | |
| 5843 | + * perf_pending_event() | |
| 5844 | + * | |
| 5845 | + * But the event runs on CPU-B and wants disabling there. | |
| 5846 | + */ | |
| 5847 | + irq_work_queue_on(&event->pending, cpu); | |
| 5848 | +} | |
| 5849 | + | |
| 5813 | 5850 | static void perf_pending_event(struct irq_work *entry) |
| 5814 | 5851 | { |
| 5815 | − struct perf_event *event = container_of(entry, | |
| 5816 | − struct perf_event, pending); | |
| 5852 | + struct perf_event *event = container_of(entry, struct perf_event, pending); | |
| 5817 | 5853 | int rctx; |
| 5818 | 5854 | |
| 5819 | 5855 | rctx = perf_swevent_get_recursion_context(); |
| @@ -5822,10 +5858,7 @@ static void perf_pending_event(struct irq_work *entry) · 2 unmodified lines | ||
| 5822 | 5858 | * and we won't recurse 'further'. |
| 5823 | 5859 | */ |
| 5824 | 5860 | |
| 5825 | − if (event->pending_disable) { | |
| 5826 | − event->pending_disable = 0; | |
| 5827 | − perf_event_disable_local(event); | |
| 5828 | − } | |
| 5861 | + perf_pending_event_disable(event); | |
| 5829 | 5862 | |
| 5830 | 5863 | if (event->pending_wakeup) { |
| 5831 | 5864 | event->pending_wakeup = 0; |
| @@ -10236,6 +10269,7 @@ perf_event_alloc(struct perf_event_attr *attr, int cpu, · 4404 unmodified lines | ||
| 10236 | 10269 | |
| 10237 | 10270 | |
| 10238 | 10271 | init_waitqueue_head(&event->waitq); |
| 10272 | + event->pending_disable = -1; | |
| 10239 | 10273 | init_irq_work(&event->pending, perf_pending_event); |
| 10240 | 10274 | |
| 10241 | 10275 | mutex_init(&event->mmap_mutex); |
| @@ -392,7 +392,7 @@ void *perf_aux_output_begin(struct perf_output_handle *handle, · 391 unmodified lines | ||
| 392 | 392 | * store that will be enabled on successful return |
| 393 | 393 | */ |
| 394 | 394 | if (!handle->size) { /* A, matches D */ |
| 395 | − event->pending_disable = 1; | |
| 395 | + event->pending_disable = smp_processor_id(); | |
| 396 | 396 | perf_output_wakeup(handle); |
| 397 | 397 | local_set(&rb->aux_nest, 0); |
| 398 | 398 | goto err_put; |
| @@ -480,7 +480,7 @@ void perf_aux_output_end(struct perf_output_handle *handle, unsigned long size) · 81 unmodified lines | ||
| 480 | 480 | |
| 481 | 481 | if (wakeup) { |
| 482 | 482 | if (handle->aux_flags & PERF_AUX_FLAG_TRUNCATED) |
| 483 | − handle->event->pending_disable = 1; | |
| 483 | + handle->event->pending_disable = smp_processor_id(); | |
| 484 | 484 | perf_output_wakeup(handle); |
| 485 | 485 | } |
| 486 | 486 | |
| @@ -1449,6 +1449,10 @@ int irq_chip_set_vcpu_affinity_parent(struct irq_data *data, void *vcpu_info) · 1448 unmodified lines | ||
| 1449 | 1449 | int irq_chip_set_wake_parent(struct irq_data *data, unsigned int on) |
| 1450 | 1450 | { |
| 1451 | 1451 | data = data->parent_data; |
| 1452 | + | |
| 1453 | + if (data->chip->flags & IRQCHIP_SKIP_SET_WAKE) | |
| 1454 | + return 0; | |
| 1455 | + | |
| 1452 | 1456 | if (data->chip->irq_set_wake) |
| 1453 | 1457 | return data->chip->irq_set_wake(data, on); |
| 1454 | 1458 | |
| @@ -558,6 +558,7 @@ int __init early_irq_init(void) · 557 unmodified lines | ||
| 558 | 558 | alloc_masks(&desc[i], node); |
| 559 | 559 | raw_spin_lock_init(&desc[i].lock); |
| 560 | 560 | lockdep_set_class(&desc[i].lock, &irq_desc_lock_class); |
| 561 | + mutex_init(&desc[i].request_mutex); | |
| 561 | 562 | desc_set_defaults(i, &desc[i], node, NULL, NULL); |
| 562 | 563 | } |
| 563 | 564 | return arch_early_irq_init(); |
| @@ -4689,8 +4689,8 @@ static void free_zapped_rcu(struct rcu_head *ch) · 4688 unmodified lines | ||
| 4689 | 4689 | return; |
| 4690 | 4690 | |
| 4691 | 4691 | raw_local_irq_save(flags); |
| 4692 | − if (!graph_lock()) | |
| 4693 | − goto out_irq; | |
| 4692 | + arch_spin_lock(&lockdep_lock); | |
| 4693 | + current->lockdep_recursion = 1; | |
| 4694 | 4694 | |
| 4695 | 4695 | /* closed head */ |
| 4696 | 4696 | pf = delayed_free.pf + (delayed_free.index ^ 1); |
| @@ -4702,8 +4702,8 @@ static void free_zapped_rcu(struct rcu_head *ch) · 5 unmodified lines | ||
| 4702 | 4702 | */ |
| 4703 | 4703 | call_rcu_zapped(delayed_free.pf + delayed_free.index); |
| 4704 | 4704 | |
| 4705 | − graph_unlock(); | |
| 4706 | −out_irq: | |
| 4705 | + current->lockdep_recursion = 0; | |
| 4706 | + arch_spin_unlock(&lockdep_lock); | |
| 4707 | 4707 | raw_local_irq_restore(flags); |
| 4708 | 4708 | } |
| 4709 | 4709 | |
| @@ -4744,21 +4744,17 @@ static void lockdep_free_key_range_reg(void *start, unsigned long size) · 34 unmodified lines | ||
| 4744 | 4744 | { |
| 4745 | 4745 | struct pending_free *pf; |
| 4746 | 4746 | unsigned long flags; |
| 4747 | − int locked; | |
| 4748 | 4747 | |
| 4749 | 4748 | init_data_structures_once(); |
| 4750 | 4749 | |
| 4751 | 4750 | raw_local_irq_save(flags); |
| 4752 | − locked = graph_lock(); | |
| 4753 | − if (!locked) | |
| 4754 | − goto out_irq; | |
| 4755 | − | |
| 4751 | + arch_spin_lock(&lockdep_lock); | |
| 4752 | + current->lockdep_recursion = 1; | |
| 4756 | 4753 | pf = get_pending_free(); |
| 4757 | 4754 | __lockdep_free_key_range(pf, start, size); |
| 4758 | 4755 | call_rcu_zapped(pf); |
| 4759 | − | |
| 4760 | − graph_unlock(); | |
| 4761 | −out_irq: | |
| 4756 | + current->lockdep_recursion = 0; | |
| 4757 | + arch_spin_unlock(&lockdep_lock); | |
| 4762 | 4758 | raw_local_irq_restore(flags); |
| 4763 | 4759 | |
| 4764 | 4760 | /* |
| @@ -4911,9 +4907,8 @@ void lockdep_unregister_key(struct lock_class_key *key) · 146 unmodified lines | ||
| 4911 | 4907 | return; |
| 4912 | 4908 | |
| 4913 | 4909 | raw_local_irq_save(flags); |
| 4914 | − if (!graph_lock()) | |
| 4915 | − goto out_irq; | |
| 4916 | − | |
| 4910 | + arch_spin_lock(&lockdep_lock); | |
| 4911 | + current->lockdep_recursion = 1; | |
| 4917 | 4912 | pf = get_pending_free(); |
| 4918 | 4913 | hlist_for_each_entry_rcu(k, hash_head, hash_entry) { |
| 4919 | 4914 | if (k == key) { |
| @@ -4925,8 +4920,8 @@ void lockdep_unregister_key(struct lock_class_key *key) · 5 unmodified lines | ||
| 4925 | 4920 | WARN_ON_ONCE(!found); |
| 4926 | 4921 | __lockdep_free_key_range(pf, key, 1); |
| 4927 | 4922 | call_rcu_zapped(pf); |
| 4928 | − graph_unlock(); | |
| 4929 | −out_irq: | |
| 4923 | + current->lockdep_recursion = 0; | |
| 4924 | + arch_spin_unlock(&lockdep_lock); | |
| 4930 | 4925 | raw_local_irq_restore(flags); |
| 4931 | 4926 | |
| 4932 | 4927 | /* Wait until is_dynamic_key() has finished accessing k->hash_entry. */ |
| @@ -7784,10 +7784,10 @@ static void update_cfs_rq_h_load(struct cfs_rq *cfs_rq) · 7783 unmodified lines | ||
| 7784 | 7784 | if (cfs_rq->last_h_load_update == now) |
| 7785 | 7785 | return; |
| 7786 | 7786 | |
| 7787 | − cfs_rq->h_load_next = NULL; | |
| 7787 | + WRITE_ONCE(cfs_rq->h_load_next, NULL); | |
| 7788 | 7788 | for_each_sched_entity(se) { |
| 7789 | 7789 | cfs_rq = cfs_rq_of(se); |
| 7790 | − cfs_rq->h_load_next = se; | |
| 7790 | + WRITE_ONCE(cfs_rq->h_load_next, se); | |
| 7791 | 7791 | if (cfs_rq->last_h_load_update == now) |
| 7792 | 7792 | break; |
| 7793 | 7793 | } |
| @@ -7797,7 +7797,7 @@ static void update_cfs_rq_h_load(struct cfs_rq *cfs_rq) · 3 unmodified lines | ||
| 7797 | 7797 | cfs_rq->last_h_load_update = now; |
| 7798 | 7798 | } |
| 7799 | 7799 | |
| 7800 | − while ((se = cfs_rq->h_load_next) != NULL) { | |
| 7800 | + while ((se = READ_ONCE(cfs_rq->h_load_next)) != NULL) { | |
| 7801 | 7801 | load = cfs_rq->h_load; |
| 7802 | 7802 | load = div64_ul(load * se->avg.load_avg, |
| 7803 | 7803 | cfs_rq_load_avg(cfs_rq) + 1); |
| @@ -594,7 +594,7 @@ static ktime_t alarm_timer_remaining(struct k_itimer *timr, ktime_t now) · 593 unmodified lines | ||
| 594 | 594 | { |
| 595 | 595 | struct alarm *alarm = &timr->it.alarm.alarmtimer; |
| 596 | 596 | |
| 597 | − return ktime_sub(now, alarm->node.expires); | |
| 597 | + return ktime_sub(alarm->node.expires, now); | |
| 598 | 598 | } |
| 599 | 599 | |
| 600 | 600 | /** |
| @@ -7041,12 +7041,16 @@ static void buffer_pipe_buf_release(struct pipe_inode_info *pipe, · 7040 unmodified lines | ||
| 7041 | 7041 | buf->private = 0; |
| 7042 | 7042 | } |
| 7043 | 7043 | |
| 7044 | −static void buffer_pipe_buf_get(struct pipe_inode_info *pipe, | |
| 7044 | +static bool buffer_pipe_buf_get(struct pipe_inode_info *pipe, | |
| 7045 | 7045 | struct pipe_buffer *buf) |
| 7046 | 7046 | { |
| 7047 | 7047 | struct buffer_ref *ref = (struct buffer_ref *)buf->private; |
| 7048 | 7048 | |
| 7049 | + if (ref->ref > INT_MAX/2) | |
| 7050 | + return false; | |
| 7051 | + | |
| 7049 | 7052 | ref->ref++; |
| 7053 | + return true; | |
| 7050 | 7054 | } |
| 7051 | 7055 | |
| 7052 | 7056 | /* Pipe buffer operations for a buffer. */ |
| @@ -1528,6 +1528,7 @@ EXPORT_SYMBOL(csum_and_copy_to_iter); · 1527 unmodified lines | ||
| 1528 | 1528 | size_t hash_and_copy_to_iter(const void *addr, size_t bytes, void *hashp, |
| 1529 | 1529 | struct iov_iter *i) |
| 1530 | 1530 | { |
| 1531 | +#ifdef CONFIG_CRYPTO | |
| 1531 | 1532 | struct ahash_request *hash = hashp; |
| 1532 | 1533 | struct scatterlist sg; |
| 1533 | 1534 | size_t copied; |
| @@ -1537,6 +1538,9 @@ size_t hash_and_copy_to_iter(const void *addr, size_t bytes, void *hashp, · 3 unmodified lines | ||
| 1537 | 1538 | ahash_request_set_crypt(hash, &sg, NULL, copied); |
| 1538 | 1539 | crypto_ahash_update(hash); |
| 1539 | 1540 | return copied; |
| 1541 | +#else | |
| 1542 | + return 0; | |
| 1543 | +#endif | |
| 1540 | 1544 | } |
| 1541 | 1545 | EXPORT_SYMBOL(hash_and_copy_to_iter); |
| 1542 | 1546 | |
| @@ -160,8 +160,12 @@ retry: · 159 unmodified lines | ||
| 160 | 160 | goto retry; |
| 161 | 161 | } |
| 162 | 162 | |
| 163 | − if (flags & FOLL_GET) | |
| 164 | − get_page(page); | |
| 163 | + if (flags & FOLL_GET) { | |
| 164 | + if (unlikely(!try_get_page(page))) { | |
| 165 | + page = ERR_PTR(-ENOMEM); | |
| 166 | + goto out; | |
| 167 | + } | |
| 168 | + } | |
| 165 | 169 | if (flags & FOLL_TOUCH) { |
| 166 | 170 | if ((flags & FOLL_WRITE) && |
| 167 | 171 | !pte_dirty(pte) && !PageDirty(page)) |
| @@ -298,7 +302,10 @@ retry_locked: · 130 unmodified lines | ||
| 298 | 302 | if (pmd_trans_unstable(pmd)) |
| 299 | 303 | ret = -EBUSY; |
| 300 | 304 | } else { |
| 301 | − get_page(page); | |
| 305 | + if (unlikely(!try_get_page(page))) { | |
| 306 | + spin_unlock(ptl); | |
| 307 | + return ERR_PTR(-ENOMEM); | |
| 308 | + } | |
| 302 | 309 | spin_unlock(ptl); |
| 303 | 310 | lock_page(page); |
| 304 | 311 | ret = split_huge_page(page); |
| @@ -500,7 +507,10 @@ static int get_gate_page(struct mm_struct *mm, unsigned long address, · 195 unmodified lines | ||
| 500 | 507 | if (is_device_public_page(*page)) |
| 501 | 508 | goto unmap; |
| 502 | 509 | } |
| 503 | − get_page(*page); | |
| 510 | + if (unlikely(!try_get_page(*page))) { | |
| 511 | + ret = -ENOMEM; | |
| 512 | + goto unmap; | |
| 513 | + } | |
| 504 | 514 | out: |
| 505 | 515 | ret = 0; |
| 506 | 516 | unmap: |
| @@ -1545,6 +1555,20 @@ static void undo_dev_pagemap(int *nr, int nr_start, struct page **pages) · 1038 unmodified lines | ||
| 1545 | 1555 | } |
| 1546 | 1556 | } |
| 1547 | 1557 | |
| 1558 | +/* | |
| 1559 | + * Return the compund head page with ref appropriately incremented, | |
| 1560 | + * or NULL if that failed. | |
| 1561 | + */ | |
| 1562 | +static inline struct page *try_get_compound_head(struct page *page, int refs) | |
| 1563 | +{ | |
| 1564 | + struct page *head = compound_head(page); | |
| 1565 | + if (WARN_ON_ONCE(page_ref_count(head) < 0)) | |
| 1566 | + return NULL; | |
| 1567 | + if (unlikely(!page_cache_add_speculative(head, refs))) | |
| 1568 | + return NULL; | |
| 1569 | + return head; | |
| 1570 | +} | |
| 1571 | + | |
| 1548 | 1572 | #ifdef CONFIG_ARCH_HAS_PTE_SPECIAL |
| 1549 | 1573 | static int gup_pte_range(pmd_t pmd, unsigned long addr, unsigned long end, |
| 1550 | 1574 | int write, struct page **pages, int *nr) |
| @@ -1579,9 +1603,9 @@ static int gup_pte_range(pmd_t pmd, unsigned long addr, unsigned long end, · 28 unmodified lines | ||
| 1579 | 1603 | |
| 1580 | 1604 | VM_BUG_ON(!pfn_valid(pte_pfn(pte))); |
| 1581 | 1605 | page = pte_page(pte); |
| 1582 | − head = compound_head(page); | |
| 1583 | 1606 | |
| 1584 | − if (!page_cache_get_speculative(head)) | |
| 1607 | + head = try_get_compound_head(page, 1); | |
| 1608 | + if (!head) | |
| 1585 | 1609 | goto pte_unmap; |
| 1586 | 1610 | |
| 1587 | 1611 | if (unlikely(pte_val(pte) != pte_val(*ptep))) { |
| @@ -1720,8 +1744,8 @@ static int gup_huge_pmd(pmd_t orig, pmd_t *pmdp, unsigned long addr, · 132 unmodified lines | ||
| 1720 | 1744 | refs++; |
| 1721 | 1745 | } while (addr += PAGE_SIZE, addr != end); |
| 1722 | 1746 | |
| 1723 | − head = compound_head(pmd_page(orig)); | |
| 1724 | − if (!page_cache_add_speculative(head, refs)) { | |
| 1747 | + head = try_get_compound_head(pmd_page(orig), refs); | |
| 1748 | + if (!head) { | |
| 1725 | 1749 | *nr -= refs; |
| 1726 | 1750 | return 0; |
| 1727 | 1751 | } |
| @@ -1758,8 +1782,8 @@ static int gup_huge_pud(pud_t orig, pud_t *pudp, unsigned long addr, · 30 unmodified lines | ||
| 1758 | 1782 | refs++; |
| 1759 | 1783 | } while (addr += PAGE_SIZE, addr != end); |
| 1760 | 1784 | |
| 1761 | − head = compound_head(pud_page(orig)); | |
| 1762 | − if (!page_cache_add_speculative(head, refs)) { | |
| 1785 | + head = try_get_compound_head(pud_page(orig), refs); | |
| 1786 | + if (!head) { | |
| 1763 | 1787 | *nr -= refs; |
| 1764 | 1788 | return 0; |
| 1765 | 1789 | } |
| @@ -1795,8 +1819,8 @@ static int gup_huge_pgd(pgd_t orig, pgd_t *pgdp, unsigned long addr, · 29 unmodified lines | ||
| 1795 | 1819 | refs++; |
| 1796 | 1820 | } while (addr += PAGE_SIZE, addr != end); |
| 1797 | 1821 | |
| 1798 | − head = compound_head(pgd_page(orig)); | |
| 1799 | − if (!page_cache_add_speculative(head, refs)) { | |
| 1822 | + head = try_get_compound_head(pgd_page(orig), refs); | |
| 1823 | + if (!head) { | |
| 1800 | 1824 | *nr -= refs; |
| 1801 | 1825 | return 0; |
| 1802 | 1826 | } |
| @@ -4299,6 +4299,19 @@ long follow_hugetlb_page(struct mm_struct *mm, struct vm_area_struct *vma, · 4298 unmodified lines | ||
| 4299 | 4299 | |
| 4300 | 4300 | pfn_offset = (vaddr & ~huge_page_mask(h)) >> PAGE_SHIFT; |
| 4301 | 4301 | page = pte_page(huge_ptep_get(pte)); |
| 4302 | + | |
| 4303 | + /* | |
| 4304 | + * Instead of doing 'try_get_page()' below in the same_page | |
| 4305 | + * loop, just check the count once here. | |
| 4306 | + */ | |
| 4307 | + if (unlikely(page_count(page) <= 0)) { | |
| 4308 | + if (pages) { | |
| 4309 | + spin_unlock(ptl); | |
| 4310 | + remainder = 0; | |
| 4311 | + err = -ENOMEM; | |
| 4312 | + break; | |
| 4313 | + } | |
| 4314 | + } | |
| 4302 | 4315 | same_page: |
| 4303 | 4316 | if (pages) { |
| 4304 | 4317 | pages[i] = mem_map_offset(page, pfn_offset); |
| @@ -710,7 +710,10 @@ static int lec_vcc_attach(struct atm_vcc *vcc, void __user *arg) · 709 unmodified lines | ||
| 710 | 710 | |
| 711 | 711 | static int lec_mcast_attach(struct atm_vcc *vcc, int arg) |
| 712 | 712 | { |
| 713 | − if (arg < 0 || arg >= MAX_LEC_ITF || !dev_lec[arg]) | |
| 713 | + if (arg < 0 || arg >= MAX_LEC_ITF) | |
| 714 | + return -EINVAL; | |
| 715 | + arg = array_index_nospec(arg, MAX_LEC_ITF); | |
| 716 | + if (!dev_lec[arg]) | |
| 714 | 717 | return -EINVAL; |
| 715 | 718 | vcc->proto_data = dev_lec[arg]; |
| 716 | 719 | return lec_mcast_make(netdev_priv(dev_lec[arg]), vcc); |
| @@ -728,6 +731,7 @@ static int lecd_attach(struct atm_vcc *vcc, int arg) · 11 unmodified lines | ||
| 728 | 731 | i = arg; |
| 729 | 732 | if (arg >= MAX_LEC_ITF) |
| 730 | 733 | return -EINVAL; |
| 734 | + i = array_index_nospec(arg, MAX_LEC_ITF); | |
| 731 | 735 | if (!dev_lec[i]) { |
| 732 | 736 | int size; |
| 733 | 737 | |
| @@ -523,12 +523,12 @@ static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, · 522 unmodified lines | ||
| 523 | 523 | struct sock *sk = sock->sk; |
| 524 | 524 | int err = 0; |
| 525 | 525 | |
| 526 | − BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr); | |
| 527 | − | |
| 528 | 526 | if (!addr || addr_len < sizeof(struct sockaddr_sco) || |
| 529 | 527 | addr->sa_family != AF_BLUETOOTH) |
| 530 | 528 | return -EINVAL; |
| 531 | 529 | |
| 530 | + BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr); | |
| 531 | + | |
| 532 | 532 | lock_sock(sk); |
| 533 | 533 | |
| 534 | 534 | if (sk->sk_state != BT_OPEN) { |
| @@ -196,13 +196,10 @@ static void __br_handle_local_finish(struct sk_buff *skb) · 195 unmodified lines | ||
| 196 | 196 | /* note: already called with rcu_read_lock */ |
| 197 | 197 | static int br_handle_local_finish(struct net *net, struct sock *sk, struct sk_buff *skb) |
| 198 | 198 | { |
| 199 | − struct net_bridge_port *p = br_port_get_rcu(skb->dev); | |
| 200 | − | |
| 201 | 199 | __br_handle_local_finish(skb); |
| 202 | 200 | |
| 203 | − BR_INPUT_SKB_CB(skb)->brdev = p->br->dev; | |
| 204 | − br_pass_frame_up(skb); | |
| 205 | − return 0; | |
| 201 | + /* return 1 to signal the okfn() was called so it's ok to use the skb */ | |
| 202 | + return 1; | |
| 206 | 203 | } |
| 207 | 204 | |
| 208 | 205 | static int nf_hook_bridge_pre(struct sk_buff *skb, struct sk_buff **pskb) |
| @@ -333,10 +330,18 @@ rx_handler_result_t br_handle_frame(struct sk_buff **pskb) · 124 unmodified lines | ||
| 333 | 330 | goto forward; |
| 334 | 331 | } |
| 335 | 332 | |
| 336 | − /* Deliver packet to local host only */ | |
| 337 | − NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_IN, dev_net(skb->dev), | |
| 338 | − NULL, skb, skb->dev, NULL, br_handle_local_finish); | |
| 339 | − return RX_HANDLER_CONSUMED; | |
| 333 | + /* The else clause should be hit when nf_hook(): | |
| 334 | + * - returns < 0 (drop/error) | |
| 335 | + * - returns = 0 (stolen/nf_queue) | |
| 336 | + * Thus return 1 from the okfn() to signal the skb is ok to pass | |
| 337 | + */ | |
| 338 | + if (NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_IN, | |
| 339 | + dev_net(skb->dev), NULL, skb, skb->dev, NULL, | |
| 340 | + br_handle_local_finish) == 1) { | |
| 341 | + return RX_HANDLER_PASS; | |
| 342 | + } else { | |
| 343 | + return RX_HANDLER_CONSUMED; | |
| 344 | + } | |
| 340 | 345 | } |
| 341 | 346 | |
| 342 | 347 | forward: |
| @@ -2013,7 +2013,8 @@ static void br_multicast_start_querier(struct net_bridge *br, · 2012 unmodified lines | ||
| 2013 | 2013 | |
| 2014 | 2014 | __br_multicast_open(br, query); |
| 2015 | 2015 | |
| 2016 | − list_for_each_entry(port, &br->port_list, list) { | |
| 2016 | + rcu_read_lock(); | |
| 2017 | + list_for_each_entry_rcu(port, &br->port_list, list) { | |
| 2017 | 2018 | if (port->state == BR_STATE_DISABLED || |
| 2018 | 2019 | port->state == BR_STATE_BLOCKING) |
| 2019 | 2020 | continue; |
| @@ -2025,6 +2026,7 @@ static void br_multicast_start_querier(struct net_bridge *br, · 5 unmodified lines | ||
| 2025 | 2026 | br_multicast_enable(&port->ip6_own_query); |
| 2026 | 2027 | #endif |
| 2027 | 2028 | } |
| 2029 | + rcu_read_unlock(); | |
| 2028 | 2030 | } |
| 2029 | 2031 | |
| 2030 | 2032 | int br_multicast_toggle(struct net_bridge *br, unsigned long val) |
| @@ -1441,7 +1441,7 @@ static int br_fill_info(struct sk_buff *skb, const struct net_device *brdev) · 1440 unmodified lines | ||
| 1441 | 1441 | nla_put_u8(skb, IFLA_BR_VLAN_STATS_ENABLED, |
| 1442 | 1442 | br_opt_get(br, BROPT_VLAN_STATS_ENABLED)) || |
| 1443 | 1443 | nla_put_u8(skb, IFLA_BR_VLAN_STATS_PER_PORT, |
| 1444 | − br_opt_get(br, IFLA_BR_VLAN_STATS_PER_PORT))) | |
| 1444 | + br_opt_get(br, BROPT_VLAN_STATS_PER_PORT))) | |
| 1445 | 1445 | return -EMSGSIZE; |
| 1446 | 1446 | #endif |
| 1447 | 1447 | #ifdef CONFIG_BRIDGE_IGMP_SNOOPING |
| @@ -1184,7 +1184,21 @@ int dev_change_name(struct net_device *dev, const char *newname) · 1183 unmodified lines | ||
| 1184 | 1184 | BUG_ON(!dev_net(dev)); |
| 1185 | 1185 | |
| 1186 | 1186 | net = dev_net(dev); |
| 1187 | − if (dev->flags & IFF_UP) | |
| 1187 | + | |
| 1188 | + /* Some auto-enslaved devices e.g. failover slaves are | |
| 1189 | + * special, as userspace might rename the device after | |
| 1190 | + * the interface had been brought up and running since | |
| 1191 | + * the point kernel initiated auto-enslavement. Allow | |
| 1192 | + * live name change even when these slave devices are | |
| 1193 | + * up and running. | |
| 1194 | + * | |
| 1195 | + * Typically, users of these auto-enslaving devices | |
| 1196 | + * don't actually care about slave name change, as | |
| 1197 | + * they are supposed to operate on master interface | |
| 1198 | + * directly. | |
| 1199 | + */ | |
| 1200 | + if (dev->flags & IFF_UP && | |
| 1201 | + likely(!(dev->priv_flags & IFF_LIVE_RENAME_OK))) | |
| 1188 | 1202 | return -EBUSY; |
| 1189 | 1203 | |
| 1190 | 1204 | write_seqcount_begin(&devnet_rename_seq); |
| @@ -80,14 +80,14 @@ static int failover_slave_register(struct net_device *slave_dev) · 79 unmodified lines | ||
| 80 | 80 | goto err_upper_link; |
| 81 | 81 | } |
| 82 | 82 | |
| 83 | − slave_dev->priv_flags |= IFF_FAILOVER_SLAVE; | |
| 83 | + slave_dev->priv_flags |= (IFF_FAILOVER_SLAVE | IFF_LIVE_RENAME_OK); | |
| 84 | 84 | |
| 85 | 85 | if (fops && fops->slave_register && |
| 86 | 86 | !fops->slave_register(slave_dev, failover_dev)) |
| 87 | 87 | return NOTIFY_OK; |
| 88 | 88 | |
| 89 | 89 | netdev_upper_dev_unlink(slave_dev, failover_dev); |
| 90 | − slave_dev->priv_flags &= ~IFF_FAILOVER_SLAVE; | |
| 90 | + slave_dev->priv_flags &= ~(IFF_FAILOVER_SLAVE | IFF_LIVE_RENAME_OK); | |
| 91 | 91 | err_upper_link: |
| 92 | 92 | netdev_rx_handler_unregister(slave_dev); |
| 93 | 93 | done: |
| @@ -121,7 +121,7 @@ int failover_slave_unregister(struct net_device *slave_dev) · 27 unmodified lines | ||
| 121 | 121 | |
| 122 | 122 | netdev_rx_handler_unregister(slave_dev); |
| 123 | 123 | netdev_upper_dev_unlink(slave_dev, failover_dev); |
| 124 | − slave_dev->priv_flags &= ~IFF_FAILOVER_SLAVE; | |
| 124 | + slave_dev->priv_flags &= ~(IFF_FAILOVER_SLAVE | IFF_LIVE_RENAME_OK); | |
| 125 | 125 | |
| 126 | 126 | if (fops && fops->slave_unregister && |
| 127 | 127 | !fops->slave_unregister(slave_dev, failover_dev)) |
| @@ -4462,6 +4462,8 @@ BPF_CALL_3(bpf_bind, struct bpf_sock_addr_kern *, ctx, struct sockaddr *, addr, · 4461 unmodified lines | ||
| 4462 | 4462 | * Only binding to IP is supported. |
| 4463 | 4463 | */ |
| 4464 | 4464 | err = -EINVAL; |
| 4465 | + if (addr_len < offsetofend(struct sockaddr, sa_family)) | |
| 4466 | + return err; | |
| 4465 | 4467 | if (addr->sa_family == AF_INET) { |
| 4466 | 4468 | if (addr_len < sizeof(struct sockaddr_in)) |
| 4467 | 4469 | return err; |
| @@ -1747,20 +1747,16 @@ int netdev_register_kobject(struct net_device *ndev) · 1746 unmodified lines | ||
| 1747 | 1747 | |
| 1748 | 1748 | error = device_add(dev); |
| 1749 | 1749 | if (error) |
| 1750 | − goto error_put_device; | |
| 1750 | + return error; | |
| 1751 | 1751 | |
| 1752 | 1752 | error = register_queue_kobjects(ndev); |
| 1753 | − if (error) | |
| 1754 | − goto error_device_del; | |
| 1753 | + if (error) { | |
| 1754 | + device_del(dev); | |
| 1755 | + return error; | |
| 1756 | + } | |
| 1755 | 1757 | |
| 1756 | 1758 | pm_runtime_set_memalloc_noio(dev, true); |
| 1757 | 1759 | |
| 1758 | − return 0; | |
| 1759 | − | |
| 1760 | −error_device_del: | |
| 1761 | − device_del(dev); | |
| 1762 | −error_put_device: | |
| 1763 | − put_device(dev); | |
| 1764 | 1760 | return error; |
| 1765 | 1761 | } |
| 1766 | 1762 | |
| @@ -185,9 +185,10 @@ void __init ptp_classifier_init(void) · 184 unmodified lines | ||
| 185 | 185 | { 0x16, 0, 0, 0x00000000 }, |
| 186 | 186 | { 0x06, 0, 0, 0x00000000 }, |
| 187 | 187 | }; |
| 188 | − struct sock_fprog_kern ptp_prog = { | |
| 189 | − .len = ARRAY_SIZE(ptp_filter), .filter = ptp_filter, | |
| 190 | − }; | |
| 188 | + struct sock_fprog_kern ptp_prog; | |
| 189 | + | |
| 190 | + ptp_prog.len = ARRAY_SIZE(ptp_filter); | |
| 191 | + ptp_prog.filter = ptp_filter; | |
| 191 | 192 | |
| 192 | 193 | BUG_ON(bpf_prog_create(&ptp_insns, &ptp_prog)); |
| 193 | 194 | } |
| @@ -4951,7 +4951,7 @@ static int rtnl_valid_stats_req(const struct nlmsghdr *nlh, bool strict_check, · 4950 unmodified lines | ||
| 4951 | 4951 | { |
| 4952 | 4952 | struct if_stats_msg *ifsm; |
| 4953 | 4953 | |
| 4954 | − if (nlh->nlmsg_len < sizeof(*ifsm)) { | |
| 4954 | + if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifsm))) { | |
| 4955 | 4955 | NL_SET_ERR_MSG(extack, "Invalid header for stats dump"); |
| 4956 | 4956 | return -EINVAL; |
| 4957 | 4957 | } |
| @@ -5082,7 +5082,8 @@ EXPORT_SYMBOL_GPL(skb_gso_validate_mac_len); · 5081 unmodified lines | ||
| 5082 | 5082 | |
| 5083 | 5083 | static struct sk_buff *skb_reorder_vlan_header(struct sk_buff *skb) |
| 5084 | 5084 | { |
| 5085 | − int mac_len; | |
| 5085 | + int mac_len, meta_len; | |
| 5086 | + void *meta; | |
| 5086 | 5087 | |
| 5087 | 5088 | if (skb_cow(skb, skb_headroom(skb)) < 0) { |
| 5088 | 5089 | kfree_skb(skb); |
| @@ -5094,6 +5095,13 @@ static struct sk_buff *skb_reorder_vlan_header(struct sk_buff *skb) · 5 unmodified lines | ||
| 5094 | 5095 | memmove(skb_mac_header(skb) + VLAN_HLEN, skb_mac_header(skb), |
| 5095 | 5096 | mac_len - VLAN_HLEN - ETH_TLEN); |
| 5096 | 5097 | } |
| 5098 | + | |
| 5099 | + meta_len = skb_metadata_len(skb); | |
| 5100 | + if (meta_len) { | |
| 5101 | + meta = skb_metadata_end(skb) - meta_len; | |
| 5102 | + memmove(meta + VLAN_HLEN, meta, meta_len); | |
| 5103 | + } | |
| 5104 | + | |
| 5097 | 5105 | skb->mac_header += VLAN_HLEN; |
| 5098 | 5106 | return skb; |
| 5099 | 5107 | } |
| @@ -348,7 +348,7 @@ static int sock_get_timeout(long timeo, void *optval, bool old_timeval) · 347 unmodified lines | ||
| 348 | 348 | tv.tv_usec = ((timeo % HZ) * USEC_PER_SEC) / HZ; |
| 349 | 349 | } |
| 350 | 350 | |
| 351 | − if (in_compat_syscall() && !COMPAT_USE_64BIT_TIME) { | |
| 351 | + if (old_timeval && in_compat_syscall() && !COMPAT_USE_64BIT_TIME) { | |
| 352 | 352 | struct old_timeval32 tv32 = { tv.tv_sec, tv.tv_usec }; |
| 353 | 353 | *(struct old_timeval32 *)optval = tv32; |
| 354 | 354 | return sizeof(tv32); |
| @@ -372,7 +372,7 @@ static int sock_set_timeout(long *timeo_p, char __user *optval, int optlen, bool · 17 unmodified lines | ||
| 372 | 372 | { |
| 373 | 373 | struct __kernel_sock_timeval tv; |
| 374 | 374 | |
| 375 | − if (in_compat_syscall() && !COMPAT_USE_64BIT_TIME) { | |
| 375 | + if (old_timeval && in_compat_syscall() && !COMPAT_USE_64BIT_TIME) { | |
| 376 | 376 | struct old_timeval32 tv32; |
| 377 | 377 | |
| 378 | 378 | if (optlen < sizeof(tv32)) |
| @@ -121,6 +121,7 @@ static int gue_udp_recv(struct sock *sk, struct sk_buff *skb) · 120 unmodified lines | ||
| 121 | 121 | struct guehdr *guehdr; |
| 122 | 122 | void *data; |
| 123 | 123 | u16 doffset = 0; |
| 124 | + u8 proto_ctype; | |
| 124 | 125 | |
| 125 | 126 | if (!fou) |
| 126 | 127 | return 1; |
| @@ -210,13 +211,14 @@ static int gue_udp_recv(struct sock *sk, struct sk_buff *skb) · 83 unmodified lines | ||
| 210 | 211 | if (unlikely(guehdr->control)) |
| 211 | 212 | return gue_control_message(skb, guehdr); |
| 212 | 213 | |
| 214 | + proto_ctype = guehdr->proto_ctype; | |
| 213 | 215 | __skb_pull(skb, sizeof(struct udphdr) + hdrlen); |
| 214 | 216 | skb_reset_transport_header(skb); |
| 215 | 217 | |
| 216 | 218 | if (iptunnel_pull_offloads(skb)) |
| 217 | 219 | goto drop; |
| 218 | 220 | |
| 219 | − return -guehdr->proto_ctype; | |
| 221 | + return -proto_ctype; | |
| 220 | 222 | |
| 221 | 223 | drop: |
| 222 | 224 | kfree_skb(skb); |
| @@ -1200,9 +1200,23 @@ static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie) · 1199 unmodified lines | ||
| 1200 | 1200 | |
| 1201 | 1201 | static void ipv4_link_failure(struct sk_buff *skb) |
| 1202 | 1202 | { |
| 1203 | + struct ip_options opt; | |
| 1203 | 1204 | struct rtable *rt; |
| 1205 | + int res; | |
| 1204 | 1206 | |
| 1205 | − icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0); | |
| 1207 | + /* Recompile ip options since IPCB may not be valid anymore. | |
| 1208 | + */ | |
| 1209 | + memset(&opt, 0, sizeof(opt)); | |
| 1210 | + opt.optlen = ip_hdr(skb)->ihl*4 - sizeof(struct iphdr); | |
| 1211 | + | |
| 1212 | + rcu_read_lock(); | |
| 1213 | + res = __ip_options_compile(dev_net(skb->dev), &opt, skb, NULL); | |
| 1214 | + rcu_read_unlock(); | |
| 1215 | + | |
| 1216 | + if (res) | |
| 1217 | + return; | |
| 1218 | + | |
| 1219 | + __icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0, &opt); | |
| 1206 | 1220 | |
| 1207 | 1221 | rt = skb_rtable(skb); |
| 1208 | 1222 | if (rt) |
| @@ -49,9 +49,8 @@ · 48 unmodified lines | ||
| 49 | 49 | #define DCTCP_MAX_ALPHA 1024U |
| 50 | 50 | |
| 51 | 51 | struct dctcp { |
| 52 | − u32 acked_bytes_ecn; | |
| 53 | − u32 acked_bytes_total; | |
| 54 | − u32 prior_snd_una; | |
| 52 | + u32 old_delivered; | |
| 53 | + u32 old_delivered_ce; | |
| 55 | 54 | u32 prior_rcv_nxt; |
| 56 | 55 | u32 dctcp_alpha; |
| 57 | 56 | u32 next_seq; |
| @@ -73,8 +72,8 @@ static void dctcp_reset(const struct tcp_sock *tp, struct dctcp *ca) · 15 unmodified lines | ||
| 73 | 72 | { |
| 74 | 73 | ca->next_seq = tp->snd_nxt; |
| 75 | 74 | |
| 76 | − ca->acked_bytes_ecn = 0; | |
| 77 | − ca->acked_bytes_total = 0; | |
| 75 | + ca->old_delivered = tp->delivered; | |
| 76 | + ca->old_delivered_ce = tp->delivered_ce; | |
| 78 | 77 | } |
| 79 | 78 | |
| 80 | 79 | static void dctcp_init(struct sock *sk) |
| @@ -86,7 +85,6 @@ static void dctcp_init(struct sock *sk) · 5 unmodified lines | ||
| 86 | 85 | sk->sk_state == TCP_CLOSE)) { |
| 87 | 86 | struct dctcp *ca = inet_csk_ca(sk); |
| 88 | 87 | |
| 89 | − ca->prior_snd_una = tp->snd_una; | |
| 90 | 88 | ca->prior_rcv_nxt = tp->rcv_nxt; |
| 91 | 89 | |
| 92 | 90 | ca->dctcp_alpha = min(dctcp_alpha_on_init, DCTCP_MAX_ALPHA); |
| @@ -118,37 +116,25 @@ static void dctcp_update_alpha(struct sock *sk, u32 flags) · 25 unmodified lines | ||
| 118 | 116 | { |
| 119 | 117 | const struct tcp_sock *tp = tcp_sk(sk); |
| 120 | 118 | struct dctcp *ca = inet_csk_ca(sk); |
| 121 | − u32 acked_bytes = tp->snd_una - ca->prior_snd_una; | |
| 122 | − | |
| 123 | − /* If ack did not advance snd_una, count dupack as MSS size. | |
| 124 | − * If ack did update window, do not count it at all. | |
| 125 | − */ | |
| 126 | − if (acked_bytes == 0 && !(flags & CA_ACK_WIN_UPDATE)) | |
| 127 | − acked_bytes = inet_csk(sk)->icsk_ack.rcv_mss; | |
| 128 | − if (acked_bytes) { | |
| 129 | − ca->acked_bytes_total += acked_bytes; | |
| 130 | − ca->prior_snd_una = tp->snd_una; | |
| 131 | − | |
| 132 | − if (flags & CA_ACK_ECE) | |
| 133 | − ca->acked_bytes_ecn += acked_bytes; | |
| 134 | − } | |
| 135 | 119 | |
| 136 | 120 | /* Expired RTT */ |
| 137 | 121 | if (!before(tp->snd_una, ca->next_seq)) { |
| 138 | − u64 bytes_ecn = ca->acked_bytes_ecn; | |
| 122 | + u32 delivered_ce = tp->delivered_ce - ca->old_delivered_ce; | |
| 139 | 123 | u32 alpha = ca->dctcp_alpha; |
| 140 | 124 | |
| 141 | 125 | /* alpha = (1 - g) * alpha + g * F */ |
| 142 | 126 | |
| 143 | 127 | alpha -= min_not_zero(alpha, alpha >> dctcp_shift_g); |
| 144 | − if (bytes_ecn) { | |
| 128 | + if (delivered_ce) { | |
| 129 | + u32 delivered = tp->delivered - ca->old_delivered; | |
| 130 | + | |
| 145 | 131 | /* If dctcp_shift_g == 1, a 32bit value would overflow |
| 146 | − * after 8 Mbytes. | |
| 132 | + * after 8 M packets. | |
| 147 | 133 | */ |
| 148 | − bytes_ecn <<= (10 - dctcp_shift_g); | |
| 149 | − do_div(bytes_ecn, max(1U, ca->acked_bytes_total)); | |
| 134 | + delivered_ce <<= (10 - dctcp_shift_g); | |
| 135 | + delivered_ce /= max(1U, delivered); | |
| 150 | 136 | |
| 151 | − alpha = min(alpha + (u32)bytes_ecn, DCTCP_MAX_ALPHA); | |
| 137 | + alpha = min(alpha + delivered_ce, DCTCP_MAX_ALPHA); | |
| 152 | 138 | } |
| 153 | 139 | /* dctcp_alpha can be read from dctcp_get_info() without |
| 154 | 140 | * synchro, so we ask compiler to not use dctcp_alpha |
| @@ -200,6 +186,7 @@ static size_t dctcp_get_info(struct sock *sk, u32 ext, int *attr, · 45 unmodified lines | ||
| 200 | 186 | union tcp_cc_info *info) |
| 201 | 187 | { |
| 202 | 188 | const struct dctcp *ca = inet_csk_ca(sk); |
| 189 | + const struct tcp_sock *tp = tcp_sk(sk); | |
| 203 | 190 | |
| 204 | 191 | /* Fill it also in case of VEGASINFO due to req struct limits. |
| 205 | 192 | * We can still correctly retrieve it later. |
| @@ -211,8 +198,10 @@ static size_t dctcp_get_info(struct sock *sk, u32 ext, int *attr, · 5 unmodified lines | ||
| 211 | 198 | info->dctcp.dctcp_enabled = 1; |
| 212 | 199 | info->dctcp.dctcp_ce_state = (u16) ca->ce_state; |
| 213 | 200 | info->dctcp.dctcp_alpha = ca->dctcp_alpha; |
| 214 | − info->dctcp.dctcp_ab_ecn = ca->acked_bytes_ecn; | |
| 215 | − info->dctcp.dctcp_ab_tot = ca->acked_bytes_total; | |
| 201 | + info->dctcp.dctcp_ab_ecn = tp->mss_cache * | |
| 202 | + (tp->delivered_ce - ca->old_delivered_ce); | |
| 203 | + info->dctcp.dctcp_ab_tot = tp->mss_cache * | |
| 204 | + (tp->delivered - ca->old_delivered); | |
| 216 | 205 | } |
| 217 | 206 | |
| 218 | 207 | *attr = INET_DIAG_DCTCPINFO; |
| @@ -402,11 +402,12 @@ static int __tcp_grow_window(const struct sock *sk, const struct sk_buff *skb) · 401 unmodified lines | ||
| 402 | 402 | static void tcp_grow_window(struct sock *sk, const struct sk_buff *skb) |
| 403 | 403 | { |
| 404 | 404 | struct tcp_sock *tp = tcp_sk(sk); |
| 405 | + int room; | |
| 406 | + | |
| 407 | + room = min_t(int, tp->window_clamp, tcp_space(sk)) - tp->rcv_ssthresh; | |
| 405 | 408 | |
| 406 | 409 | /* Check #1 */ |
| 407 | − if (tp->rcv_ssthresh < tp->window_clamp && | |
| 408 | − (int)tp->rcv_ssthresh < tcp_space(sk) && | |
| 409 | − !tcp_under_memory_pressure(sk)) { | |
| 410 | + if (room > 0 && !tcp_under_memory_pressure(sk)) { | |
| 410 | 411 | int incr; |
| 411 | 412 | |
| 412 | 413 | /* Check #2. Increase window, if skb with such overhead |
| @@ -419,8 +420,7 @@ static void tcp_grow_window(struct sock *sk, const struct sk_buff *skb) · 6 unmodified lines | ||
| 419 | 420 | |
| 420 | 421 | if (incr) { |
| 421 | 422 | incr = max_t(int, incr, 2 * skb->len); |
| 422 | − tp->rcv_ssthresh = min(tp->rcv_ssthresh + incr, | |
| 423 | − tp->window_clamp); | |
| 423 | + tp->rcv_ssthresh += min(room, incr); | |
| 424 | 424 | inet_csk(sk)->icsk_ack.quick |= 1; |
| 425 | 425 | } |
| 426 | 426 | } |
| @@ -2331,6 +2331,10 @@ static void __ip6_rt_update_pmtu(struct dst_entry *dst, const struct sock *sk, · 2330 unmodified lines | ||
| 2331 | 2331 | |
| 2332 | 2332 | rcu_read_lock(); |
| 2333 | 2333 | from = rcu_dereference(rt6->from); |
| 2334 | + if (!from) { | |
| 2335 | + rcu_read_unlock(); | |
| 2336 | + return; | |
| 2337 | + } | |
| 2334 | 2338 | nrt6 = ip6_rt_cache_alloc(from, daddr, saddr); |
| 2335 | 2339 | if (nrt6) { |
| 2336 | 2340 | rt6_do_update_pmtu(nrt6, mtu); |
| @@ -1045,6 +1045,8 @@ static void udp_v6_flush_pending_frames(struct sock *sk) · 1044 unmodified lines | ||
| 1045 | 1045 | static int udpv6_pre_connect(struct sock *sk, struct sockaddr *uaddr, |
| 1046 | 1046 | int addr_len) |
| 1047 | 1047 | { |
| 1048 | + if (addr_len < offsetofend(struct sockaddr, sa_family)) | |
| 1049 | + return -EINVAL; | |
| 1048 | 1050 | /* The following checks are replicated from __ip6_datagram_connect() |
| 1049 | 1051 | * and intended to prevent BPF program called below from accessing |
| 1050 | 1052 | * bytes that are out of the bound specified by user in addr_len. |
| @@ -320,14 +320,13 @@ static int llc_ui_bind(struct socket *sock, struct sockaddr *uaddr, int addrlen) · 319 unmodified lines | ||
| 320 | 320 | struct llc_sap *sap; |
| 321 | 321 | int rc = -EINVAL; |
| 322 | 322 | |
| 323 | − dprintk("%s: binding %02X\n", __func__, addr->sllc_sap); | |
| 324 | − | |
| 325 | 323 | lock_sock(sk); |
| 326 | 324 | if (unlikely(!sock_flag(sk, SOCK_ZAPPED) || addrlen != sizeof(*addr))) |
| 327 | 325 | goto out; |
| 328 | 326 | rc = -EAFNOSUPPORT; |
| 329 | 327 | if (unlikely(addr->sllc_family != AF_LLC)) |
| 330 | 328 | goto out; |
| 329 | + dprintk("%s: binding %02X\n", __func__, addr->sllc_sap); | |
| 331 | 330 | rc = -ENODEV; |
| 332 | 331 | rcu_read_lock(); |
| 333 | 332 | if (sk->sk_bound_dev_if) { |
| @@ -1195,6 +1195,9 @@ static inline void drv_wake_tx_queue(struct ieee80211_local *local, · 1194 unmodified lines | ||
| 1195 | 1195 | { |
| 1196 | 1196 | struct ieee80211_sub_if_data *sdata = vif_to_sdata(txq->txq.vif); |
| 1197 | 1197 | |
| 1198 | + if (local->in_reconfig) | |
| 1199 | + return; | |
| 1200 | + | |
| 1198 | 1201 | if (!check_sdata_in_driver(sdata)) |
| 1199 | 1202 | return; |
| 1200 | 1203 | |
| @@ -167,8 +167,10 @@ static int ieee80211_key_enable_hw_accel(struct ieee80211_key *key) · 166 unmodified lines | ||
| 167 | 167 | * The driver doesn't know anything about VLAN interfaces. |
| 168 | 168 | * Hence, don't send GTKs for VLAN interfaces to the driver. |
| 169 | 169 | */ |
| 170 | − if (!(key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE)) | |
| 170 | + if (!(key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE)) { | |
| 171 | + ret = 1; | |
| 171 | 172 | goto out_unsupported; |
| 173 | + } | |
| 172 | 174 | } |
| 173 | 175 | |
| 174 | 176 | ret = drv_set_key(key->local, SET_KEY, sdata, |
| @@ -213,11 +215,8 @@ static int ieee80211_key_enable_hw_accel(struct ieee80211_key *key) · 38 unmodified lines | ||
| 213 | 215 | /* all of these we can do in software - if driver can */ |
| 214 | 216 | if (ret == 1) |
| 215 | 217 | return 0; |
| 216 | − if (ieee80211_hw_check(&key->local->hw, SW_CRYPTO_CONTROL)) { | |
| 217 | − if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) | |
| 218 | − return 0; | |
| 218 | + if (ieee80211_hw_check(&key->local->hw, SW_CRYPTO_CONTROL)) | |
| 219 | 219 | return -EINVAL; |
| 220 | − } | |
| 221 | 220 | return 0; |
| 222 | 221 | default: |
| 223 | 222 | return -EINVAL; |
| @@ -23,7 +23,7 @@ static void mesh_path_free_rcu(struct mesh_table *tbl, struct mesh_path *mpath); · 22 unmodified lines | ||
| 23 | 23 | static u32 mesh_table_hash(const void *addr, u32 len, u32 seed) |
| 24 | 24 | { |
| 25 | 25 | /* Use last four bytes of hw addr as hash index */ |
| 26 | − return jhash_1word(*(u32 *)(addr+2), seed); | |
| 26 | + return jhash_1word(__get_unaligned_cpu32((u8 *)addr + 2), seed); | |
| 27 | 27 | } |
| 28 | 28 | |
| 29 | 29 | static const struct rhashtable_params mesh_rht_params = { |
| @@ -1568,7 +1568,15 @@ static void sta_ps_start(struct sta_info *sta) · 1567 unmodified lines | ||
| 1568 | 1568 | return; |
| 1569 | 1569 | |
| 1570 | 1570 | for (tid = 0; tid < IEEE80211_NUM_TIDS; tid++) { |
| 1571 | − if (txq_has_queue(sta->sta.txq[tid])) | |
| 1571 | + struct ieee80211_txq *txq = sta->sta.txq[tid]; | |
| 1572 | + struct txq_info *txqi = to_txq_info(txq); | |
| 1573 | + | |
| 1574 | + spin_lock(&local->active_txq_lock[txq->ac]); | |
| 1575 | + if (!list_empty(&txqi->schedule_order)) | |
| 1576 | + list_del_init(&txqi->schedule_order); | |
| 1577 | + spin_unlock(&local->active_txq_lock[txq->ac]); | |
| 1578 | + | |
| 1579 | + if (txq_has_queue(txq)) | |
| 1572 | 1580 | set_bit(tid, &sta->txq_buffered_tids); |
| 1573 | 1581 | else |
| 1574 | 1582 | clear_bit(tid, &sta->txq_buffered_tids); |
| @@ -1,4 +1,9 @@ | ||
| 1 | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
| 2 | +/* | |
| 3 | + * Portions of this file | |
| 4 | + * Copyright (C) 2019 Intel Corporation | |
| 5 | + */ | |
| 6 | + | |
| 2 | 7 | #ifdef CONFIG_MAC80211_MESSAGE_TRACING |
| 3 | 8 | |
| 4 | 9 | #if !defined(__MAC80211_MSG_DRIVER_TRACE) || defined(TRACE_HEADER_MULTI_READ) |
| @@ -11,7 +16,7 @@ · 6 unmodified lines | ||
| 11 | 16 | #undef TRACE_SYSTEM |
| 12 | 17 | #define TRACE_SYSTEM mac80211_msg |
| 13 | 18 | |
| 14 | −#define MAX_MSG_LEN 100 | |
| 19 | +#define MAX_MSG_LEN 120 | |
| 15 | 20 | |
| 16 | 21 | DECLARE_EVENT_CLASS(mac80211_msg_event, |
| 17 | 22 | TP_PROTO(struct va_format *vaf), |
| @@ -3221,6 +3221,7 @@ static bool ieee80211_amsdu_aggregate(struct ieee80211_sub_if_data *sdata, · 3220 unmodified lines | ||
| 3221 | 3221 | u8 max_subframes = sta->sta.max_amsdu_subframes; |
| 3222 | 3222 | int max_frags = local->hw.max_tx_fragments; |
| 3223 | 3223 | int max_amsdu_len = sta->sta.max_amsdu_len; |
| 3224 | + int orig_truesize; | |
| 3224 | 3225 | __be16 len; |
| 3225 | 3226 | void *data; |
| 3226 | 3227 | bool ret = false; |
| @@ -3261,6 +3262,7 @@ static bool ieee80211_amsdu_aggregate(struct ieee80211_sub_if_data *sdata, · 34 unmodified lines | ||
| 3261 | 3262 | if (!head || skb_is_gso(head)) |
| 3262 | 3263 | goto out; |
| 3263 | 3264 | |
| 3265 | + orig_truesize = head->truesize; | |
| 3264 | 3266 | orig_len = head->len; |
| 3265 | 3267 | |
| 3266 | 3268 | if (skb->len + head->len > max_amsdu_len) |
| @@ -3318,6 +3320,7 @@ static bool ieee80211_amsdu_aggregate(struct ieee80211_sub_if_data *sdata, · 51 unmodified lines | ||
| 3318 | 3320 | *frag_tail = skb; |
| 3319 | 3321 | |
| 3320 | 3322 | out_recalc: |
| 3323 | + fq->memory_usage += head->truesize - orig_truesize; | |
| 3321 | 3324 | if (head->len != orig_len) { |
| 3322 | 3325 | flow->backlog += head->len - orig_len; |
| 3323 | 3326 | tin->backlog_bytes += head->len - orig_len; |
| @@ -3646,16 +3649,17 @@ EXPORT_SYMBOL(ieee80211_tx_dequeue); · 322 unmodified lines | ||
| 3646 | 3649 | struct ieee80211_txq *ieee80211_next_txq(struct ieee80211_hw *hw, u8 ac) |
| 3647 | 3650 | { |
| 3648 | 3651 | struct ieee80211_local *local = hw_to_local(hw); |
| 3652 | + struct ieee80211_txq *ret = NULL; | |
| 3649 | 3653 | struct txq_info *txqi = NULL; |
| 3650 | 3654 | |
| 3651 | − lockdep_assert_held(&local->active_txq_lock[ac]); | |
| 3655 | + spin_lock_bh(&local->active_txq_lock[ac]); | |
| 3652 | 3656 | |
| 3653 | 3657 | begin: |
| 3654 | 3658 | txqi = list_first_entry_or_null(&local->active_txqs[ac], |
| 3655 | 3659 | struct txq_info, |
| 3656 | 3660 | schedule_order); |
| 3657 | 3661 | if (!txqi) |
| 3658 | − return NULL; | |
| 3662 | + goto out; | |
| 3659 | 3663 | |
| 3660 | 3664 | if (txqi->txq.sta) { |
| 3661 | 3665 | struct sta_info *sta = container_of(txqi->txq.sta, |
| @@ -3672,24 +3676,30 @@ struct ieee80211_txq *ieee80211_next_txq(struct ieee80211_hw *hw, u8 ac) · 10 unmodified lines | ||
| 3672 | 3676 | |
| 3673 | 3677 | |
| 3674 | 3678 | if (txqi->schedule_round == local->schedule_round[ac]) |
| 3675 | − return NULL; | |
| 3679 | + goto out; | |
| 3676 | 3680 | |
| 3677 | 3681 | list_del_init(&txqi->schedule_order); |
| 3678 | 3682 | txqi->schedule_round = local->schedule_round[ac]; |
| 3679 | − return &txqi->txq; | |
| 3683 | + ret = &txqi->txq; | |
| 3684 | + | |
| 3685 | +out: | |
| 3686 | + spin_unlock_bh(&local->active_txq_lock[ac]); | |
| 3687 | + return ret; | |
| 3680 | 3688 | } |
| 3681 | 3689 | EXPORT_SYMBOL(ieee80211_next_txq); |
| 3682 | 3690 | |
| 3683 | −void ieee80211_return_txq(struct ieee80211_hw *hw, | |
| 3684 | − struct ieee80211_txq *txq) | |
| 3691 | +void __ieee80211_schedule_txq(struct ieee80211_hw *hw, | |
| 3692 | + struct ieee80211_txq *txq, | |
| 3693 | + bool force) | |
| 3685 | 3694 | { |
| 3686 | 3695 | struct ieee80211_local *local = hw_to_local(hw); |
| 3687 | 3696 | struct txq_info *txqi = to_txq_info(txq); |
| 3688 | 3697 | |
| 3689 | − lockdep_assert_held(&local->active_txq_lock[txq->ac]); | |
| 3698 | + spin_lock_bh(&local->active_txq_lock[txq->ac]); | |
| 3690 | 3699 | |
| 3691 | 3700 | if (list_empty(&txqi->schedule_order) && |
| 3692 | − (!skb_queue_empty(&txqi->frags) || txqi->tin.backlog_packets)) { | |
| 3701 | + (force || !skb_queue_empty(&txqi->frags) || | |
| 3702 | + txqi->tin.backlog_packets)) { | |
| 3693 | 3703 | /* If airtime accounting is active, always enqueue STAs at the |
| 3694 | 3704 | * head of the list to ensure that they only get moved to the |
| 3695 | 3705 | * back by the airtime DRR scheduler once they have a negative |
| @@ -3706,20 +3716,10 @@ void ieee80211_return_txq(struct ieee80211_hw *hw, · 10 unmodified lines | ||
| 3706 | 3716 | list_add_tail(&txqi->schedule_order, |
| 3707 | 3717 | &local->active_txqs[txq->ac]); |
| 3708 | 3718 | } |
| 3709 | −} | |
| 3710 | −EXPORT_SYMBOL(ieee80211_return_txq); | |
| 3711 | 3719 | |
| 3712 | −void ieee80211_schedule_txq(struct ieee80211_hw *hw, | |
| 3713 | − struct ieee80211_txq *txq) | |
| 3714 | − __acquires(txq_lock) __releases(txq_lock) | |
| 3715 | −{ | |
| 3716 | − struct ieee80211_local *local = hw_to_local(hw); | |
| 3717 | − | |
| 3718 | − spin_lock_bh(&local->active_txq_lock[txq->ac]); | |
| 3719 | − ieee80211_return_txq(hw, txq); | |
| 3720 | 3720 | spin_unlock_bh(&local->active_txq_lock[txq->ac]); |
| 3721 | 3721 | } |
| 3722 | −EXPORT_SYMBOL(ieee80211_schedule_txq); | |
| 3722 | +EXPORT_SYMBOL(__ieee80211_schedule_txq); | |
| 3723 | 3723 | |
| 3724 | 3724 | bool ieee80211_txq_may_transmit(struct ieee80211_hw *hw, |
| 3725 | 3725 | struct ieee80211_txq *txq) |
| @@ -3729,7 +3729,7 @@ bool ieee80211_txq_may_transmit(struct ieee80211_hw *hw, · 3 unmodified lines | ||
| 3729 | 3729 | struct sta_info *sta; |
| 3730 | 3730 | u8 ac = txq->ac; |
| 3731 | 3731 | |
| 3732 | − lockdep_assert_held(&local->active_txq_lock[ac]); | |
| 3732 | + spin_lock_bh(&local->active_txq_lock[ac]); | |
| 3733 | 3733 | |
| 3734 | 3734 | if (!txqi->txq.sta) |
| 3735 | 3735 | goto out; |
| @@ -3759,34 +3759,27 @@ bool ieee80211_txq_may_transmit(struct ieee80211_hw *hw, · 23 unmodified lines | ||
| 3759 | 3759 | |
| 3760 | 3760 | sta->airtime[ac].deficit += sta->airtime_weight; |
| 3761 | 3761 | list_move_tail(&txqi->schedule_order, &local->active_txqs[ac]); |
| 3762 | + spin_unlock_bh(&local->active_txq_lock[ac]); | |
| 3762 | 3763 | |
| 3763 | 3764 | return false; |
| 3764 | 3765 | out: |
| 3765 | 3766 | if (!list_empty(&txqi->schedule_order)) |
| 3766 | 3767 | list_del_init(&txqi->schedule_order); |
| 3768 | + spin_unlock_bh(&local->active_txq_lock[ac]); | |
| 3767 | 3769 | |
| 3768 | 3770 | return true; |
| 3769 | 3771 | } |
| 3770 | 3772 | EXPORT_SYMBOL(ieee80211_txq_may_transmit); |
| 3771 | 3773 | |
| 3772 | 3774 | void ieee80211_txq_schedule_start(struct ieee80211_hw *hw, u8 ac) |
| 3773 | − __acquires(txq_lock) | |
| 3774 | 3775 | { |
| 3775 | 3776 | struct ieee80211_local *local = hw_to_local(hw); |
| 3776 | 3777 | |
| 3777 | 3778 | spin_lock_bh(&local->active_txq_lock[ac]); |
| 3778 | 3779 | local->schedule_round[ac]++; |
| 3779 | −} | |
| 3780 | −EXPORT_SYMBOL(ieee80211_txq_schedule_start); | |
| 3781 | − | |
| 3782 | −void ieee80211_txq_schedule_end(struct ieee80211_hw *hw, u8 ac) | |
| 3783 | − __releases(txq_lock) | |
| 3784 | −{ | |
| 3785 | − struct ieee80211_local *local = hw_to_local(hw); | |
| 3786 | − | |
| 3787 | 3780 | spin_unlock_bh(&local->active_txq_lock[ac]); |
| 3788 | 3781 | } |
| 3789 | −EXPORT_SYMBOL(ieee80211_txq_schedule_end); | |
| 3782 | +EXPORT_SYMBOL(ieee80211_txq_schedule_start); | |
| 3790 | 3783 | |
| 3791 | 3784 | void __ieee80211_subif_start_xmit(struct sk_buff *skb, |
| 3792 | 3785 | struct net_device *dev, |
| @@ -988,7 +988,7 @@ static int netlink_bind(struct socket *sock, struct sockaddr *addr, · 987 unmodified lines | ||
| 988 | 988 | struct netlink_sock *nlk = nlk_sk(sk); |
| 989 | 989 | struct sockaddr_nl *nladdr = (struct sockaddr_nl *)addr; |
| 990 | 990 | int err = 0; |
| 991 | − unsigned long groups = nladdr->nl_groups; | |
| 991 | + unsigned long groups; | |
| 992 | 992 | bool bound; |
| 993 | 993 | |
| 994 | 994 | if (addr_len < sizeof(struct sockaddr_nl)) |
| @@ -996,6 +996,7 @@ static int netlink_bind(struct socket *sock, struct sockaddr *addr, · 1 unmodified line | ||
| 996 | 996 | |
| 997 | 997 | if (nladdr->nl_family != AF_NETLINK) |
| 998 | 998 | return -EINVAL; |
| 999 | + groups = nladdr->nl_groups; | |
| 999 | 1000 | |
| 1000 | 1001 | /* Only superuser is allowed to listen multicasts */ |
| 1001 | 1002 | if (groups) { |
| @@ -1392,18 +1392,22 @@ static int __init nr_proto_init(void) · 1391 unmodified lines | ||
| 1392 | 1392 | int i; |
| 1393 | 1393 | int rc = proto_register(&nr_proto, 0); |
| 1394 | 1394 | |
| 1395 | − if (rc != 0) | |
| 1396 | − goto out; | |
| 1395 | + if (rc) | |
| 1396 | + return rc; | |
| 1397 | 1397 | |
| 1398 | 1398 | if (nr_ndevs > 0x7fffffff/sizeof(struct net_device *)) { |
| 1399 | − printk(KERN_ERR "NET/ROM: nr_proto_init - nr_ndevs parameter to large\n"); | |
| 1400 | − return -1; | |
| 1399 | + pr_err("NET/ROM: %s - nr_ndevs parameter too large\n", | |
| 1400 | + __func__); | |
| 1401 | + rc = -EINVAL; | |
| 1402 | + goto unregister_proto; | |
| 1401 | 1403 | } |
| 1402 | 1404 | |
| 1403 | 1405 | dev_nr = kcalloc(nr_ndevs, sizeof(struct net_device *), GFP_KERNEL); |
| 1404 | − if (dev_nr == NULL) { | |
| 1405 | − printk(KERN_ERR "NET/ROM: nr_proto_init - unable to allocate device array\n"); | |
| 1406 | − return -1; | |
| 1406 | + if (!dev_nr) { | |
| 1407 | + pr_err("NET/ROM: %s - unable to allocate device array\n", | |
| 1408 | + __func__); | |
| 1409 | + rc = -ENOMEM; | |
| 1410 | + goto unregister_proto; | |
| 1407 | 1411 | } |
| 1408 | 1412 | |
| 1409 | 1413 | for (i = 0; i < nr_ndevs; i++) { |
| @@ -1413,13 +1417,13 @@ static int __init nr_proto_init(void) · 3 unmodified lines | ||
| 1413 | 1417 | sprintf(name, "nr%d", i); |
| 1414 | 1418 | dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, nr_setup); |
| 1415 | 1419 | if (!dev) { |
| 1416 | − printk(KERN_ERR "NET/ROM: nr_proto_init - unable to allocate device structure\n"); | |
| 1420 | + rc = -ENOMEM; | |
| 1417 | 1421 | goto fail; |
| 1418 | 1422 | } |
| 1419 | 1423 | |
| 1420 | 1424 | dev->base_addr = i; |
| 1421 | − if (register_netdev(dev)) { | |
| 1422 | − printk(KERN_ERR "NET/ROM: nr_proto_init - unable to register network device\n"); | |
| 1425 | + rc = register_netdev(dev); | |
| 1426 | + if (rc) { | |
| 1423 | 1427 | free_netdev(dev); |
| 1424 | 1428 | goto fail; |
| 1425 | 1429 | } |
| @@ -1427,36 +1431,64 @@ static int __init nr_proto_init(void) · 1 unmodified line | ||
| 1427 | 1431 | dev_nr[i] = dev; |
| 1428 | 1432 | } |
| 1429 | 1433 | |
| 1430 | − if (sock_register(&nr_family_ops)) { | |
| 1431 | − printk(KERN_ERR "NET/ROM: nr_proto_init - unable to register socket family\n"); | |
| 1434 | + rc = sock_register(&nr_family_ops); | |
| 1435 | + if (rc) | |
| 1432 | 1436 | goto fail; |
| 1433 | − } | |
| 1434 | 1437 | |
| 1435 | − register_netdevice_notifier(&nr_dev_notifier); | |
| 1438 | + rc = register_netdevice_notifier(&nr_dev_notifier); | |
| 1439 | + if (rc) | |
| 1440 | + goto out_sock; | |
| 1436 | 1441 | |
| 1437 | 1442 | ax25_register_pid(&nr_pid); |
| 1438 | 1443 | ax25_linkfail_register(&nr_linkfail_notifier); |
| 1439 | 1444 | |
| 1440 | 1445 | #ifdef CONFIG_SYSCTL |
| 1441 | − nr_register_sysctl(); | |
| 1446 | + rc = nr_register_sysctl(); | |
| 1447 | + if (rc) | |
| 1448 | + goto out_sysctl; | |
| 1442 | 1449 | #endif |
| 1443 | 1450 | |
| 1444 | 1451 | nr_loopback_init(); |
| 1445 | 1452 | |
| 1446 | − proc_create_seq("nr", 0444, init_net.proc_net, &nr_info_seqops); | |
| 1447 | − proc_create_seq("nr_neigh", 0444, init_net.proc_net, &nr_neigh_seqops); | |
| 1448 | − proc_create_seq("nr_nodes", 0444, init_net.proc_net, &nr_node_seqops); | |
| 1449 | −out: | |
| 1450 | − return rc; | |
| 1453 | + rc = -ENOMEM; | |
| 1454 | + if (!proc_create_seq("nr", 0444, init_net.proc_net, &nr_info_seqops)) | |
| 1455 | + goto proc_remove1; | |
| 1456 | + if (!proc_create_seq("nr_neigh", 0444, init_net.proc_net, | |
| 1457 | + &nr_neigh_seqops)) | |
| 1458 | + goto proc_remove2; | |
| 1459 | + if (!proc_create_seq("nr_nodes", 0444, init_net.proc_net, | |
| 1460 | + &nr_node_seqops)) | |
| 1461 | + goto proc_remove3; | |
| 1462 | + | |
| 1463 | + return 0; | |
| 1464 | + | |
| 1465 | +proc_remove3: | |
| 1466 | + remove_proc_entry("nr_neigh", init_net.proc_net); | |
| 1467 | +proc_remove2: | |
| 1468 | + remove_proc_entry("nr", init_net.proc_net); | |
| 1469 | +proc_remove1: | |
| 1470 | + | |
| 1471 | + nr_loopback_clear(); | |
| 1472 | + nr_rt_free(); | |
| 1473 | + | |
| 1474 | +#ifdef CONFIG_SYSCTL | |
| 1475 | + nr_unregister_sysctl(); | |
| 1476 | +out_sysctl: | |
| 1477 | +#endif | |
| 1478 | + ax25_linkfail_release(&nr_linkfail_notifier); | |
| 1479 | + ax25_protocol_release(AX25_P_NETROM); | |
| 1480 | + unregister_netdevice_notifier(&nr_dev_notifier); | |
| 1481 | +out_sock: | |
| 1482 | + sock_unregister(PF_NETROM); | |
| 1451 | 1483 | fail: |
| 1452 | 1484 | while (--i >= 0) { |
| 1453 | 1485 | unregister_netdev(dev_nr[i]); |
| 1454 | 1486 | free_netdev(dev_nr[i]); |
| 1455 | 1487 | } |
| 1456 | 1488 | kfree(dev_nr); |
| 1489 | +unregister_proto: | |
| 1457 | 1490 | proto_unregister(&nr_proto); |
| 1458 | − rc = -1; | |
| 1459 | − goto out; | |
| 1491 | + return rc; | |
| 1460 | 1492 | } |
| 1461 | 1493 | |
| 1462 | 1494 | module_init(nr_proto_init); |
| @@ -70,7 +70,7 @@ static void nr_loopback_timer(struct timer_list *unused) · 69 unmodified lines | ||
| 70 | 70 | } |
| 71 | 71 | } |
| 72 | 72 | |
| 73 | −void __exit nr_loopback_clear(void) | |
| 73 | +void nr_loopback_clear(void) | |
| 74 | 74 | { |
| 75 | 75 | del_timer_sync(&loopback_timer); |
| 76 | 76 | skb_queue_purge(&loopback_queue); |
| @@ -953,7 +953,7 @@ const struct seq_operations nr_neigh_seqops = { · 952 unmodified lines | ||
| 953 | 953 | /* |
| 954 | 954 | * Free all memory associated with the nodes and routes lists. |
| 955 | 955 | */ |
| 956 | −void __exit nr_rt_free(void) | |
| 956 | +void nr_rt_free(void) | |
| 957 | 957 | { |
| 958 | 958 | struct nr_neigh *s = NULL; |
| 959 | 959 | struct nr_node *t = NULL; |
| @@ -146,9 +146,12 @@ static struct ctl_table nr_table[] = { · 145 unmodified lines | ||
| 146 | 146 | { } |
| 147 | 147 | }; |
| 148 | 148 | |
| 149 | −void __init nr_register_sysctl(void) | |
| 149 | +int __init nr_register_sysctl(void) | |
| 150 | 150 | { |
| 151 | 151 | nr_table_header = register_net_sysctl(&init_net, "net/netrom", nr_table); |
| 152 | + if (!nr_table_header) | |
| 153 | + return -ENOMEM; | |
| 154 | + return 0; | |
| 152 | 155 | } |
| 153 | 156 | |
| 154 | 157 | void nr_unregister_sysctl(void) |
| @@ -543,6 +543,9 @@ static int rds_connect(struct socket *sock, struct sockaddr *uaddr, · 542 unmodified lines | ||
| 543 | 543 | struct rds_sock *rs = rds_sk_to_rs(sk); |
| 544 | 544 | int ret = 0; |
| 545 | 545 | |
| 546 | + if (addr_len < offsetofend(struct sockaddr, sa_family)) | |
| 547 | + return -EINVAL; | |
| 548 | + | |
| 546 | 549 | lock_sock(sk); |
| 547 | 550 | |
| 548 | 551 | switch (uaddr->sa_family) { |
| @@ -173,6 +173,8 @@ int rds_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) · 172 unmodified lines | ||
| 173 | 173 | /* We allow an RDS socket to be bound to either IPv4 or IPv6 |
| 174 | 174 | * address. |
| 175 | 175 | */ |
| 176 | + if (addr_len < offsetofend(struct sockaddr, sa_family)) | |
| 177 | + return -EINVAL; | |
| 176 | 178 | if (uaddr->sa_family == AF_INET) { |
| 177 | 179 | struct sockaddr_in *sin = (struct sockaddr_in *)uaddr; |
| 178 | 180 | |
| @@ -135,7 +135,7 @@ static int rxrpc_bind(struct socket *sock, struct sockaddr *saddr, int len) · 134 unmodified lines | ||
| 135 | 135 | struct sockaddr_rxrpc *srx = (struct sockaddr_rxrpc *)saddr; |
| 136 | 136 | struct rxrpc_local *local; |
| 137 | 137 | struct rxrpc_sock *rx = rxrpc_sk(sock->sk); |
| 138 | − u16 service_id = srx->srx_service; | |
| 138 | + u16 service_id; | |
| 139 | 139 | int ret; |
| 140 | 140 | |
| 141 | 141 | _enter("%p,%p,%d", rx, saddr, len); |
| @@ -143,6 +143,7 @@ static int rxrpc_bind(struct socket *sock, struct sockaddr *saddr, int len) · 1 unmodified line | ||
| 143 | 143 | ret = rxrpc_validate_address(rx, srx, len); |
| 144 | 144 | if (ret < 0) |
| 145 | 145 | goto error; |
| 146 | + service_id = srx->srx_service; | |
| 146 | 147 | |
| 147 | 148 | lock_sock(&rx->sk); |
| 148 | 149 | |
| @@ -370,18 +371,22 @@ EXPORT_SYMBOL(rxrpc_kernel_end_call); · 221 unmodified lines | ||
| 370 | 371 | * rxrpc_kernel_check_life - Check to see whether a call is still alive |
| 371 | 372 | * @sock: The socket the call is on |
| 372 | 373 | * @call: The call to check |
| 374 | + * @_life: Where to store the life value | |
| 373 | 375 | * |
| 374 | 376 | * Allow a kernel service to find out whether a call is still alive - ie. we're |
| 375 | − * getting ACKs from the server. Returns a number representing the life state | |
| 376 | − * which can be compared to that returned by a previous call. | |
| 377 | + * getting ACKs from the server. Passes back in *_life a number representing | |
| 378 | + * the life state which can be compared to that returned by a previous call and | |
| 379 | + * return true if the call is still alive. | |
| 377 | 380 | * |
| 378 | 381 | * If the life state stalls, rxrpc_kernel_probe_life() should be called and |
| 379 | 382 | * then 2RTT waited. |
| 380 | 383 | */ |
| 381 | −u32 rxrpc_kernel_check_life(const struct socket *sock, | |
| 382 | − const struct rxrpc_call *call) | |
| 384 | +bool rxrpc_kernel_check_life(const struct socket *sock, | |
| 385 | + const struct rxrpc_call *call, | |
| 386 | + u32 *_life) | |
| 383 | 387 | { |
| 384 | − return call->acks_latest; | |
| 388 | + *_life = call->acks_latest; | |
| 389 | + return call->state != RXRPC_CALL_COMPLETE; | |
| 385 | 390 | } |
| 386 | 391 | EXPORT_SYMBOL(rxrpc_kernel_check_life); |
| 387 | 392 | |
| @@ -654,6 +654,7 @@ struct rxrpc_call { · 653 unmodified lines | ||
| 654 | 654 | u8 ackr_reason; /* reason to ACK */ |
| 655 | 655 | u16 ackr_skew; /* skew on packet being ACK'd */ |
| 656 | 656 | rxrpc_serial_t ackr_serial; /* serial of packet being ACK'd */ |
| 657 | + rxrpc_serial_t ackr_first_seq; /* first sequence number received */ | |
| 657 | 658 | rxrpc_seq_t ackr_prev_seq; /* previous sequence number received */ |
| 658 | 659 | rxrpc_seq_t ackr_consumed; /* Highest packet shown consumed */ |
| 659 | 660 | rxrpc_seq_t ackr_seen; /* Highest packet shown seen */ |
| @@ -153,7 +153,8 @@ static void rxrpc_conn_retransmit_call(struct rxrpc_connection *conn, · 152 unmodified lines | ||
| 153 | 153 | * pass a connection-level abort onto all calls on that connection |
| 154 | 154 | */ |
| 155 | 155 | static void rxrpc_abort_calls(struct rxrpc_connection *conn, |
| 156 | − enum rxrpc_call_completion compl) | |
| 156 | + enum rxrpc_call_completion compl, | |
| 157 | + rxrpc_serial_t serial) | |
| 157 | 158 | { |
| 158 | 159 | struct rxrpc_call *call; |
| 159 | 160 | int i; |
| @@ -173,6 +174,9 @@ static void rxrpc_abort_calls(struct rxrpc_connection *conn, · 13 unmodified lines | ||
| 173 | 174 | call->call_id, 0, |
| 174 | 175 | conn->abort_code, |
| 175 | 176 | conn->error); |
| 177 | + else | |
| 178 | + trace_rxrpc_rx_abort(call, serial, | |
| 179 | + conn->abort_code); | |
| 176 | 180 | if (rxrpc_set_call_completion(call, compl, |
| 177 | 181 | conn->abort_code, |
| 178 | 182 | conn->error)) |
| @@ -213,8 +217,6 @@ static int rxrpc_abort_connection(struct rxrpc_connection *conn, · 34 unmodified lines | ||
| 213 | 217 | conn->state = RXRPC_CONN_LOCALLY_ABORTED; |
| 214 | 218 | spin_unlock_bh(&conn->state_lock); |
| 215 | 219 | |
| 216 | − rxrpc_abort_calls(conn, RXRPC_CALL_LOCALLY_ABORTED); | |
| 217 | − | |
| 218 | 220 | msg.msg_name = &conn->params.peer->srx.transport; |
| 219 | 221 | msg.msg_namelen = conn->params.peer->srx.transport_len; |
| 220 | 222 | msg.msg_control = NULL; |
| @@ -242,6 +244,7 @@ static int rxrpc_abort_connection(struct rxrpc_connection *conn, · 21 unmodified lines | ||
| 242 | 244 | len = iov[0].iov_len + iov[1].iov_len; |
| 243 | 245 | |
| 244 | 246 | serial = atomic_inc_return(&conn->serial); |
| 247 | + rxrpc_abort_calls(conn, RXRPC_CALL_LOCALLY_ABORTED, serial); | |
| 245 | 248 | whdr.serial = htonl(serial); |
| 246 | 249 | _proto("Tx CONN ABORT %%%u { %d }", serial, conn->abort_code); |
| 247 | 250 | |
| @@ -321,7 +324,7 @@ static int rxrpc_process_event(struct rxrpc_connection *conn, · 73 unmodified lines | ||
| 321 | 324 | conn->error = -ECONNABORTED; |
| 322 | 325 | conn->abort_code = abort_code; |
| 323 | 326 | conn->state = RXRPC_CONN_REMOTELY_ABORTED; |
| 324 | − rxrpc_abort_calls(conn, RXRPC_CALL_REMOTELY_ABORTED); | |
| 327 | + rxrpc_abort_calls(conn, RXRPC_CALL_REMOTELY_ABORTED, sp->hdr.serial); | |
| 325 | 328 | return -ECONNABORTED; |
| 326 | 329 | |
| 327 | 330 | case RXRPC_PACKET_TYPE_CHALLENGE: |
| @@ -837,7 +837,7 @@ static void rxrpc_input_ack(struct rxrpc_call *call, struct sk_buff *skb, · 836 unmodified lines | ||
| 837 | 837 | u8 acks[RXRPC_MAXACKS]; |
| 838 | 838 | } buf; |
| 839 | 839 | rxrpc_serial_t acked_serial; |
| 840 | − rxrpc_seq_t first_soft_ack, hard_ack; | |
| 840 | + rxrpc_seq_t first_soft_ack, hard_ack, prev_pkt; | |
| 841 | 841 | int nr_acks, offset, ioffset; |
| 842 | 842 | |
| 843 | 843 | _enter(""); |
| @@ -851,13 +851,14 @@ static void rxrpc_input_ack(struct rxrpc_call *call, struct sk_buff *skb, · 7 unmodified lines | ||
| 851 | 851 | |
| 852 | 852 | acked_serial = ntohl(buf.ack.serial); |
| 853 | 853 | first_soft_ack = ntohl(buf.ack.firstPacket); |
| 854 | + prev_pkt = ntohl(buf.ack.previousPacket); | |
| 854 | 855 | hard_ack = first_soft_ack - 1; |
| 855 | 856 | nr_acks = buf.ack.nAcks; |
| 856 | 857 | summary.ack_reason = (buf.ack.reason < RXRPC_ACK__INVALID ? |
| 857 | 858 | buf.ack.reason : RXRPC_ACK__INVALID); |
| 858 | 859 | |
| 859 | 860 | trace_rxrpc_rx_ack(call, sp->hdr.serial, acked_serial, |
| 860 | − first_soft_ack, ntohl(buf.ack.previousPacket), | |
| 861 | + first_soft_ack, prev_pkt, | |
| 861 | 862 | summary.ack_reason, nr_acks); |
| 862 | 863 | |
| 863 | 864 | if (buf.ack.reason == RXRPC_ACK_PING_RESPONSE) |
| @@ -878,8 +879,9 @@ static void rxrpc_input_ack(struct rxrpc_call *call, struct sk_buff *skb, · 14 unmodified lines | ||
| 878 | 879 | rxrpc_propose_ack_respond_to_ack); |
| 879 | 880 | } |
| 880 | 881 | |
| 881 | − /* Discard any out-of-order or duplicate ACKs. */ | |
| 882 | − if (before_eq(sp->hdr.serial, call->acks_latest)) | |
| 882 | + /* Discard any out-of-order or duplicate ACKs (outside lock). */ | |
| 883 | + if (before(first_soft_ack, call->ackr_first_seq) || | |
| 884 | + before(prev_pkt, call->ackr_prev_seq)) | |
| 883 | 885 | return; |
| 884 | 886 | |
| 885 | 887 | buf.info.rxMTU = 0; |
| @@ -890,12 +892,16 @@ static void rxrpc_input_ack(struct rxrpc_call *call, struct sk_buff *skb, · 4 unmodified lines | ||
| 890 | 892 | |
| 891 | 893 | spin_lock(&call->input_lock); |
| 892 | 894 | |
| 893 | − /* Discard any out-of-order or duplicate ACKs. */ | |
| 894 | − if (before_eq(sp->hdr.serial, call->acks_latest)) | |
| 895 | + /* Discard any out-of-order or duplicate ACKs (inside lock). */ | |
| 896 | + if (before(first_soft_ack, call->ackr_first_seq) || | |
| 897 | + before(prev_pkt, call->ackr_prev_seq)) | |
| 895 | 898 | goto out; |
| 896 | 899 | call->acks_latest_ts = skb->tstamp; |
| 897 | 900 | call->acks_latest = sp->hdr.serial; |
| 898 | 901 | |
| 902 | + call->ackr_first_seq = first_soft_ack; | |
| 903 | + call->ackr_prev_seq = prev_pkt; | |
| 904 | + | |
| 899 | 905 | /* Parse rwind and mtu sizes if provided. */ |
| 900 | 906 | if (buf.info.rxMTU) |
| 901 | 907 | rxrpc_input_ackinfo(call, skb, &buf.info); |
| @@ -157,6 +157,11 @@ void rxrpc_error_report(struct sock *sk) · 156 unmodified lines | ||
| 157 | 157 | |
| 158 | 158 | _enter("%p{%d}", sk, local->debug_id); |
| 159 | 159 | |
| 160 | + /* Clear the outstanding error value on the socket so that it doesn't | |
| 161 | + * cause kernel_sendmsg() to return it later. | |
| 162 | + */ | |
| 163 | + sock_error(sk); | |
| 164 | + | |
| 160 | 165 | skb = sock_dequeue_err_skb(sk); |
| 161 | 166 | if (!skb) { |
| 162 | 167 | _leave("UDP socket errqueue empty"); |
| @@ -152,12 +152,13 @@ static void rxrpc_notify_end_tx(struct rxrpc_sock *rx, struct rxrpc_call *call, · 151 unmodified lines | ||
| 152 | 152 | } |
| 153 | 153 | |
| 154 | 154 | /* |
| 155 | − * Queue a DATA packet for transmission, set the resend timeout and send the | |
| 156 | − * packet immediately | |
| 155 | + * Queue a DATA packet for transmission, set the resend timeout and send | |
| 156 | + * the packet immediately. Returns the error from rxrpc_send_data_packet() | |
| 157 | + * in case the caller wants to do something with it. | |
| 157 | 158 | */ |
| 158 | −static void rxrpc_queue_packet(struct rxrpc_sock *rx, struct rxrpc_call *call, | |
| 159 | − struct sk_buff *skb, bool last, | |
| 160 | − rxrpc_notify_end_tx_t notify_end_tx) | |
| 159 | +static int rxrpc_queue_packet(struct rxrpc_sock *rx, struct rxrpc_call *call, | |
| 160 | + struct sk_buff *skb, bool last, | |
| 161 | + rxrpc_notify_end_tx_t notify_end_tx) | |
| 161 | 162 | { |
| 162 | 163 | struct rxrpc_skb_priv *sp = rxrpc_skb(skb); |
| 163 | 164 | unsigned long now; |
| @@ -250,7 +251,8 @@ static void rxrpc_queue_packet(struct rxrpc_sock *rx, struct rxrpc_call *call, · 86 unmodified lines | ||
| 250 | 251 | |
| 251 | 252 | out: |
| 252 | 253 | rxrpc_free_skb(skb, rxrpc_skb_tx_freed); |
| 253 | − _leave(""); | |
| 254 | + _leave(" = %d", ret); | |
| 255 | + return ret; | |
| 254 | 256 | } |
| 255 | 257 | |
| 256 | 258 | /* |
| @@ -423,9 +425,10 @@ static int rxrpc_send_data(struct rxrpc_sock *rx, · 166 unmodified lines | ||
| 423 | 425 | if (ret < 0) |
| 424 | 426 | goto out; |
| 425 | 427 | |
| 426 | − rxrpc_queue_packet(rx, call, skb, | |
| 427 | − !msg_data_left(msg) && !more, | |
| 428 | − notify_end_tx); | |
| 428 | + ret = rxrpc_queue_packet(rx, call, skb, | |
| 429 | + !msg_data_left(msg) && !more, | |
| 430 | + notify_end_tx); | |
| 431 | + /* Should check for failure here */ | |
| 429 | 432 | skb = NULL; |
| 430 | 433 | } |
| 431 | 434 | } while (msg_data_left(msg) > 0); |
| @@ -4850,7 +4850,8 @@ static int sctp_connect(struct sock *sk, struct sockaddr *addr, · 4849 unmodified lines | ||
| 4850 | 4850 | } |
| 4851 | 4851 | |
| 4852 | 4852 | /* Validate addr_len before calling common connect/connectx routine. */ |
| 4853 | − af = sctp_get_af_specific(addr->sa_family); | |
| 4853 | + af = addr_len < offsetofend(struct sockaddr, sa_family) ? NULL : | |
| 4854 | + sctp_get_af_specific(addr->sa_family); | |
| 4854 | 4855 | if (!af || addr_len < af->sockaddr_len) { |
| 4855 | 4856 | err = -EINVAL; |
| 4856 | 4857 | } else { |
| @@ -165,10 +165,9 @@ static int smc_release(struct socket *sock) · 164 unmodified lines | ||
| 165 | 165 | |
| 166 | 166 | if (sk->sk_state == SMC_CLOSED) { |
| 167 | 167 | if (smc->clcsock) { |
| 168 | − mutex_lock(&smc->clcsock_release_lock); | |
| 169 | − sock_release(smc->clcsock); | |
| 170 | − smc->clcsock = NULL; | |
| 171 | − mutex_unlock(&smc->clcsock_release_lock); | |
| 168 | + release_sock(sk); | |
| 169 | + smc_clcsock_release(smc); | |
| 170 | + lock_sock(sk); | |
| 172 | 171 | } |
| 173 | 172 | if (!smc->use_fallback) |
| 174 | 173 | smc_conn_free(&smc->conn); |
| @@ -444,10 +443,19 @@ static void smc_link_save_peer_info(struct smc_link *link, · 269 unmodified lines | ||
| 444 | 443 | link->peer_mtu = clc->qp_mtu; |
| 445 | 444 | } |
| 446 | 445 | |
| 446 | +static void smc_switch_to_fallback(struct smc_sock *smc) | |
| 447 | +{ | |
| 448 | + smc->use_fallback = true; | |
| 449 | + if (smc->sk.sk_socket && smc->sk.sk_socket->file) { | |
| 450 | + smc->clcsock->file = smc->sk.sk_socket->file; | |
| 451 | + smc->clcsock->file->private_data = smc->clcsock; | |
| 452 | + } | |
| 453 | +} | |
| 454 | + | |
| 447 | 455 | /* fall back during connect */ |
| 448 | 456 | static int smc_connect_fallback(struct smc_sock *smc, int reason_code) |
| 449 | 457 | { |
| 450 | − smc->use_fallback = true; | |
| 458 | + smc_switch_to_fallback(smc); | |
| 451 | 459 | smc->fallback_rsn = reason_code; |
| 452 | 460 | smc_copy_sock_settings_to_clc(smc); |
| 453 | 461 | smc->connect_nonblock = 0; |
| @@ -780,10 +788,14 @@ static void smc_connect_work(struct work_struct *work) · 326 unmodified lines | ||
| 780 | 788 | smc->sk.sk_err = -rc; |
| 781 | 789 | |
| 782 | 790 | out: |
| 783 | − if (smc->sk.sk_err) | |
| 784 | − smc->sk.sk_state_change(&smc->sk); | |
| 785 | − else | |
| 786 | − smc->sk.sk_write_space(&smc->sk); | |
| 791 | + if (!sock_flag(&smc->sk, SOCK_DEAD)) { | |
| 792 | + if (smc->sk.sk_err) { | |
| 793 | + smc->sk.sk_state_change(&smc->sk); | |
| 794 | + } else { /* allow polling before and after fallback decision */ | |
| 795 | + smc->clcsock->sk->sk_write_space(smc->clcsock->sk); | |
| 796 | + smc->sk.sk_write_space(&smc->sk); | |
| 797 | + } | |
| 798 | + } | |
| 787 | 799 | release_sock(&smc->sk); |
| 788 | 800 | } |
| 789 | 801 | |
| @@ -867,11 +879,11 @@ static int smc_clcsock_accept(struct smc_sock *lsmc, struct smc_sock **new_smc) · 77 unmodified lines | ||
| 867 | 879 | if (rc < 0) |
| 868 | 880 | lsk->sk_err = -rc; |
| 869 | 881 | if (rc < 0 || lsk->sk_state == SMC_CLOSED) { |
| 882 | + new_sk->sk_prot->unhash(new_sk); | |
| 870 | 883 | if (new_clcsock) |
| 871 | 884 | sock_release(new_clcsock); |
| 872 | 885 | new_sk->sk_state = SMC_CLOSED; |
| 873 | 886 | sock_set_flag(new_sk, SOCK_DEAD); |
| 874 | − new_sk->sk_prot->unhash(new_sk); | |
| 875 | 887 | sock_put(new_sk); /* final */ |
| 876 | 888 | *new_smc = NULL; |
| 877 | 889 | goto out; |
| @@ -922,16 +934,21 @@ struct sock *smc_accept_dequeue(struct sock *parent, · 44 unmodified lines | ||
| 922 | 934 | |
| 923 | 935 | smc_accept_unlink(new_sk); |
| 924 | 936 | if (new_sk->sk_state == SMC_CLOSED) { |
| 937 | + new_sk->sk_prot->unhash(new_sk); | |
| 925 | 938 | if (isk->clcsock) { |
| 926 | 939 | sock_release(isk->clcsock); |
| 927 | 940 | isk->clcsock = NULL; |
| 928 | 941 | } |
| 929 | − new_sk->sk_prot->unhash(new_sk); | |
| 930 | 942 | sock_put(new_sk); /* final */ |
| 931 | 943 | continue; |
| 932 | 944 | } |
| 933 | − if (new_sock) | |
| 945 | + if (new_sock) { | |
| 934 | 946 | sock_graft(new_sk, new_sock); |
| 947 | + if (isk->use_fallback) { | |
| 948 | + smc_sk(new_sk)->clcsock->file = new_sock->file; | |
| 949 | + isk->clcsock->file->private_data = isk->clcsock; | |
| 950 | + } | |
| 951 | + } | |
| 935 | 952 | return new_sk; |
| 936 | 953 | } |
| 937 | 954 | return NULL; |
| @@ -951,6 +968,7 @@ void smc_close_non_accepted(struct sock *sk) · 13 unmodified lines | ||
| 951 | 968 | sock_set_flag(sk, SOCK_DEAD); |
| 952 | 969 | sk->sk_shutdown |= SHUTDOWN_MASK; |
| 953 | 970 | } |
| 971 | + sk->sk_prot->unhash(sk); | |
| 954 | 972 | if (smc->clcsock) { |
| 955 | 973 | struct socket *tcp; |
| 956 | 974 | |
| @@ -966,7 +984,6 @@ void smc_close_non_accepted(struct sock *sk) · 9 unmodified lines | ||
| 966 | 984 | smc_conn_free(&smc->conn); |
| 967 | 985 | } |
| 968 | 986 | release_sock(sk); |
| 969 | − sk->sk_prot->unhash(sk); | |
| 970 | 987 | sock_put(sk); /* final sock_put */ |
| 971 | 988 | } |
| 972 | 989 | |
| @@ -1032,13 +1049,13 @@ static void smc_listen_out(struct smc_sock *new_smc) · 59 unmodified lines | ||
| 1032 | 1049 | struct smc_sock *lsmc = new_smc->listen_smc; |
| 1033 | 1050 | struct sock *newsmcsk = &new_smc->sk; |
| 1034 | 1051 | |
| 1035 | − lock_sock_nested(&lsmc->sk, SINGLE_DEPTH_NESTING); | |
| 1036 | 1052 | if (lsmc->sk.sk_state == SMC_LISTEN) { |
| 1053 | + lock_sock_nested(&lsmc->sk, SINGLE_DEPTH_NESTING); | |
| 1037 | 1054 | smc_accept_enqueue(&lsmc->sk, newsmcsk); |
| 1055 | + release_sock(&lsmc->sk); | |
| 1038 | 1056 | } else { /* no longer listening */ |
| 1039 | 1057 | smc_close_non_accepted(newsmcsk); |
| 1040 | 1058 | } |
| 1041 | − release_sock(&lsmc->sk); | |
| 1042 | 1059 | |
| 1043 | 1060 | /* Wake up accept */ |
| 1044 | 1061 | lsmc->sk.sk_data_ready(&lsmc->sk); |
| @@ -1082,7 +1099,7 @@ static void smc_listen_decline(struct smc_sock *new_smc, int reason_code, · 37 unmodified lines | ||
| 1082 | 1099 | return; |
| 1083 | 1100 | } |
| 1084 | 1101 | smc_conn_free(&new_smc->conn); |
| 1085 | − new_smc->use_fallback = true; | |
| 1102 | + smc_switch_to_fallback(new_smc); | |
| 1086 | 1103 | new_smc->fallback_rsn = reason_code; |
| 1087 | 1104 | if (reason_code && reason_code != SMC_CLC_DECL_PEERDECL) { |
| 1088 | 1105 | if (smc_clc_send_decline(new_smc, reason_code) < 0) { |
| @@ -1220,6 +1237,9 @@ static void smc_listen_work(struct work_struct *work) · 131 unmodified lines | ||
| 1220 | 1237 | u8 buf[SMC_CLC_MAX_LEN]; |
| 1221 | 1238 | int rc = 0; |
| 1222 | 1239 | |
| 1240 | + if (new_smc->listen_smc->sk.sk_state != SMC_LISTEN) | |
| 1241 | + return smc_listen_out_err(new_smc); | |
| 1242 | + | |
| 1223 | 1243 | if (new_smc->use_fallback) { |
| 1224 | 1244 | smc_listen_out_connected(new_smc); |
| 1225 | 1245 | return; |
| @@ -1227,7 +1247,7 @@ static void smc_listen_work(struct work_struct *work) · 1 unmodified line | ||
| 1227 | 1247 | |
| 1228 | 1248 | /* check if peer is smc capable */ |
| 1229 | 1249 | if (!tcp_sk(newclcsock->sk)->syn_smc) { |
| 1230 | − new_smc->use_fallback = true; | |
| 1250 | + smc_switch_to_fallback(new_smc); | |
| 1231 | 1251 | new_smc->fallback_rsn = SMC_CLC_DECL_PEERNOSMC; |
| 1232 | 1252 | smc_listen_out_connected(new_smc); |
| 1233 | 1253 | return; |
| @@ -1507,7 +1527,7 @@ static int smc_sendmsg(struct socket *sock, struct msghdr *msg, size_t len) · 273 unmodified lines | ||
| 1507 | 1527 | |
| 1508 | 1528 | if (msg->msg_flags & MSG_FASTOPEN) { |
| 1509 | 1529 | if (sk->sk_state == SMC_INIT) { |
| 1510 | − smc->use_fallback = true; | |
| 1530 | + smc_switch_to_fallback(smc); | |
| 1511 | 1531 | smc->fallback_rsn = SMC_CLC_DECL_OPTUNSUPP; |
| 1512 | 1532 | } else { |
| 1513 | 1533 | rc = -EINVAL; |
| @@ -1712,7 +1732,7 @@ static int smc_setsockopt(struct socket *sock, int level, int optname, · 198 unmodified lines | ||
| 1712 | 1732 | case TCP_FASTOPEN_NO_COOKIE: |
| 1713 | 1733 | /* option not supported by SMC */ |
| 1714 | 1734 | if (sk->sk_state == SMC_INIT) { |
| 1715 | − smc->use_fallback = true; | |
| 1735 | + smc_switch_to_fallback(smc); | |
| 1716 | 1736 | smc->fallback_rsn = SMC_CLC_DECL_OPTUNSUPP; |
| 1717 | 1737 | } else { |
| 1718 | 1738 | if (!smc->use_fallback) |
| @@ -21,6 +21,22 @@ · 20 unmodified lines | ||
| 21 | 21 | |
| 22 | 22 | #define SMC_CLOSE_WAIT_LISTEN_CLCSOCK_TIME (5 * HZ) |
| 23 | 23 | |
| 24 | +/* release the clcsock that is assigned to the smc_sock */ | |
| 25 | +void smc_clcsock_release(struct smc_sock *smc) | |
| 26 | +{ | |
| 27 | + struct socket *tcp; | |
| 28 | + | |
| 29 | + if (smc->listen_smc && current_work() != &smc->smc_listen_work) | |
| 30 | + cancel_work_sync(&smc->smc_listen_work); | |
| 31 | + mutex_lock(&smc->clcsock_release_lock); | |
| 32 | + if (smc->clcsock) { | |
| 33 | + tcp = smc->clcsock; | |
| 34 | + smc->clcsock = NULL; | |
| 35 | + sock_release(tcp); | |
| 36 | + } | |
| 37 | + mutex_unlock(&smc->clcsock_release_lock); | |
| 38 | +} | |
| 39 | + | |
| 24 | 40 | static void smc_close_cleanup_listen(struct sock *parent) |
| 25 | 41 | { |
| 26 | 42 | struct sock *sk; |
| @@ -321,6 +337,7 @@ static void smc_close_passive_work(struct work_struct *work) · 294 unmodified lines | ||
| 321 | 337 | close_work); |
| 322 | 338 | struct smc_sock *smc = container_of(conn, struct smc_sock, conn); |
| 323 | 339 | struct smc_cdc_conn_state_flags *rxflags; |
| 340 | + bool release_clcsock = false; | |
| 324 | 341 | struct sock *sk = &smc->sk; |
| 325 | 342 | int old_state; |
| 326 | 343 | |
| @@ -400,13 +417,13 @@ wakeup: · 73 unmodified lines | ||
| 400 | 417 | if ((sk->sk_state == SMC_CLOSED) && |
| 401 | 418 | (sock_flag(sk, SOCK_DEAD) || !sk->sk_socket)) { |
| 402 | 419 | smc_conn_free(conn); |
| 403 | − if (smc->clcsock) { | |
| 404 | − sock_release(smc->clcsock); | |
| 405 | − smc->clcsock = NULL; | |
| 406 | − } | |
| 420 | + if (smc->clcsock) | |
| 421 | + release_clcsock = true; | |
| 407 | 422 | } |
| 408 | 423 | } |
| 409 | 424 | release_sock(sk); |
| 425 | + if (release_clcsock) | |
| 426 | + smc_clcsock_release(smc); | |
| 410 | 427 | sock_put(sk); /* sock_hold done by schedulers of close_work */ |
| 411 | 428 | } |
| 412 | 429 | |
| @@ -23,5 +23,6 @@ void smc_close_wake_tx_prepared(struct smc_sock *smc); · 22 unmodified lines | ||
| 23 | 23 | int smc_close_active(struct smc_sock *smc); |
| 24 | 24 | int smc_close_shutdown_write(struct smc_sock *smc); |
| 25 | 25 | void smc_close_init(struct smc_sock *smc); |
| 26 | +void smc_clcsock_release(struct smc_sock *smc); | |
| 26 | 27 | |
| 27 | 28 | #endif /* SMC_CLOSE_H */ |
| @@ -289,6 +289,11 @@ struct smcd_dev *smcd_alloc_dev(struct device *parent, const char *name, · 288 unmodified lines | ||
| 289 | 289 | INIT_LIST_HEAD(&smcd->vlan); |
| 290 | 290 | smcd->event_wq = alloc_ordered_workqueue("ism_evt_wq-%s)", |
| 291 | 291 | WQ_MEM_RECLAIM, name); |
| 292 | + if (!smcd->event_wq) { | |
| 293 | + kfree(smcd->conn); | |
| 294 | + kfree(smcd); | |
| 295 | + return NULL; | |
| 296 | + } | |
| 292 | 297 | return smcd; |
| 293 | 298 | } |
| 294 | 299 | EXPORT_SYMBOL_GPL(smcd_alloc_dev); |
| @@ -604,7 +604,8 @@ static int smc_pnet_flush(struct sk_buff *skb, struct genl_info *info) · 603 unmodified lines | ||
| 604 | 604 | { |
| 605 | 605 | struct net *net = genl_info_net(info); |
| 606 | 606 | |
| 607 | − return smc_pnet_remove_by_pnetid(net, NULL); | |
| 607 | + smc_pnet_remove_by_pnetid(net, NULL); | |
| 608 | + return 0; | |
| 608 | 609 | } |
| 609 | 610 | |
| 610 | 611 | /* SMC_PNETID generic netlink operation definition */ |
| @@ -140,13 +140,11 @@ static int __strp_recv(read_descriptor_t *desc, struct sk_buff *orig_skb, · 139 unmodified lines | ||
| 140 | 140 | /* We are going to append to the frags_list of head. |
| 141 | 141 | * Need to unshare the frag_list. |
| 142 | 142 | */ |
| 143 | − if (skb_has_frag_list(head)) { | |
| 144 | − err = skb_unclone(head, GFP_ATOMIC); | |
| 145 | − if (err) { | |
| 146 | − STRP_STATS_INCR(strp->stats.mem_fail); | |
| 147 | − desc->error = err; | |
| 148 | − return 0; | |
| 149 | − } | |
| 143 | + err = skb_unclone(head, GFP_ATOMIC); | |
| 144 | + if (err) { | |
| 145 | + STRP_STATS_INCR(strp->stats.mem_fail); | |
| 146 | + desc->error = err; | |
| 147 | + return 0; | |
| 150 | 148 | } |
| 151 | 149 | |
| 152 | 150 | if (unlikely(skb_shinfo(head)->frag_list)) { |
| @@ -1540,7 +1540,6 @@ call_start(struct rpc_task *task) · 1539 unmodified lines | ||
| 1540 | 1540 | clnt->cl_stats->rpccnt++; |
| 1541 | 1541 | task->tk_action = call_reserve; |
| 1542 | 1542 | rpc_task_set_transport(task, clnt); |
| 1543 | − call_reserve(task); | |
| 1544 | 1543 | } |
| 1545 | 1544 | |
| 1546 | 1545 | /* |
| @@ -1554,9 +1553,6 @@ call_reserve(struct rpc_task *task) · 7 unmodified lines | ||
| 1554 | 1553 | task->tk_status = 0; |
| 1555 | 1554 | task->tk_action = call_reserveresult; |
| 1556 | 1555 | xprt_reserve(task); |
| 1557 | − if (rpc_task_need_resched(task)) | |
| 1558 | − return; | |
| 1559 | − call_reserveresult(task); | |
| 1560 | 1556 | } |
| 1561 | 1557 | |
| 1562 | 1558 | static void call_retry_reserve(struct rpc_task *task); |
| @@ -1579,7 +1575,6 @@ call_reserveresult(struct rpc_task *task) · 16 unmodified lines | ||
| 1579 | 1575 | if (status >= 0) { |
| 1580 | 1576 | if (task->tk_rqstp) { |
| 1581 | 1577 | task->tk_action = call_refresh; |
| 1582 | − call_refresh(task); | |
| 1583 | 1578 | return; |
| 1584 | 1579 | } |
| 1585 | 1580 | |
| @@ -1605,7 +1600,6 @@ call_reserveresult(struct rpc_task *task) · 19 unmodified lines | ||
| 1605 | 1600 | /* fall through */ |
| 1606 | 1601 | case -EAGAIN: /* woken up; retry */ |
| 1607 | 1602 | task->tk_action = call_retry_reserve; |
| 1608 | − call_retry_reserve(task); | |
| 1609 | 1603 | return; |
| 1610 | 1604 | case -EIO: /* probably a shutdown */ |
| 1611 | 1605 | break; |
| @@ -1628,9 +1622,6 @@ call_retry_reserve(struct rpc_task *task) · 16 unmodified lines | ||
| 1628 | 1622 | task->tk_status = 0; |
| 1629 | 1623 | task->tk_action = call_reserveresult; |
| 1630 | 1624 | xprt_retry_reserve(task); |
| 1631 | − if (rpc_task_need_resched(task)) | |
| 1632 | − return; | |
| 1633 | − call_reserveresult(task); | |
| 1634 | 1625 | } |
| 1635 | 1626 | |
| 1636 | 1627 | /* |
| @@ -1645,9 +1636,6 @@ call_refresh(struct rpc_task *task) · 8 unmodified lines | ||
| 1645 | 1636 | task->tk_status = 0; |
| 1646 | 1637 | task->tk_client->cl_stats->rpcauthrefresh++; |
| 1647 | 1638 | rpcauth_refreshcred(task); |
| 1648 | − if (rpc_task_need_resched(task)) | |
| 1649 | − return; | |
| 1650 | − call_refreshresult(task); | |
| 1651 | 1639 | } |
| 1652 | 1640 | |
| 1653 | 1641 | /* |
| @@ -1666,7 +1654,6 @@ call_refreshresult(struct rpc_task *task) · 12 unmodified lines | ||
| 1666 | 1654 | case 0: |
| 1667 | 1655 | if (rpcauth_uptodatecred(task)) { |
| 1668 | 1656 | task->tk_action = call_allocate; |
| 1669 | − call_allocate(task); | |
| 1670 | 1657 | return; |
| 1671 | 1658 | } |
| 1672 | 1659 | /* Use rate-limiting and a max number of retries if refresh |
| @@ -1685,7 +1672,6 @@ call_refreshresult(struct rpc_task *task) · 12 unmodified lines | ||
| 1685 | 1672 | task->tk_cred_retry--; |
| 1686 | 1673 | dprintk("RPC: %5u %s: retry refresh creds\n", |
| 1687 | 1674 | task->tk_pid, __func__); |
| 1688 | − call_refresh(task); | |
| 1689 | 1675 | return; |
| 1690 | 1676 | } |
| 1691 | 1677 | dprintk("RPC: %5u %s: refresh creds failed with error %d\n", |
| @@ -1711,10 +1697,8 @@ call_allocate(struct rpc_task *task) · 19 unmodified lines | ||
| 1711 | 1697 | task->tk_status = 0; |
| 1712 | 1698 | task->tk_action = call_encode; |
| 1713 | 1699 | |
| 1714 | − if (req->rq_buffer) { | |
| 1715 | − call_encode(task); | |
| 1700 | + if (req->rq_buffer) | |
| 1716 | 1701 | return; |
| 1717 | − } | |
| 1718 | 1702 | |
| 1719 | 1703 | if (proc->p_proc != 0) { |
| 1720 | 1704 | BUG_ON(proc->p_arglen == 0); |
| @@ -1740,12 +1724,8 @@ call_allocate(struct rpc_task *task) · 19 unmodified lines | ||
| 1740 | 1724 | |
| 1741 | 1725 | status = xprt->ops->buf_alloc(task); |
| 1742 | 1726 | xprt_inject_disconnect(xprt); |
| 1743 | − if (status == 0) { | |
| 1744 | − if (rpc_task_need_resched(task)) | |
| 1745 | − return; | |
| 1746 | − call_encode(task); | |
| 1727 | + if (status == 0) | |
| 1747 | 1728 | return; |
| 1748 | − } | |
| 1749 | 1729 | if (status != -ENOMEM) { |
| 1750 | 1730 | rpc_exit(task, status); |
| 1751 | 1731 | return; |
| @@ -1828,8 +1808,12 @@ call_encode(struct rpc_task *task) · 76 unmodified lines | ||
| 1828 | 1808 | xprt_request_enqueue_receive(task); |
| 1829 | 1809 | xprt_request_enqueue_transmit(task); |
| 1830 | 1810 | out: |
| 1831 | − task->tk_action = call_bind; | |
| 1832 | − call_bind(task); | |
| 1811 | + task->tk_action = call_transmit; | |
| 1812 | + /* Check that the connection is OK */ | |
| 1813 | + if (!xprt_bound(task->tk_xprt)) | |
| 1814 | + task->tk_action = call_bind; | |
| 1815 | + else if (!xprt_connected(task->tk_xprt)) | |
| 1816 | + task->tk_action = call_connect; | |
| 1833 | 1817 | } |
| 1834 | 1818 | |
| 1835 | 1819 | /* |
| @@ -1847,7 +1831,6 @@ rpc_task_handle_transmitted(struct rpc_task *task) · 11 unmodified lines | ||
| 1847 | 1831 | { |
| 1848 | 1832 | xprt_end_transmit(task); |
| 1849 | 1833 | task->tk_action = call_transmit_status; |
| 1850 | − call_transmit_status(task); | |
| 1851 | 1834 | } |
| 1852 | 1835 | |
| 1853 | 1836 | /* |
| @@ -1865,7 +1848,6 @@ call_bind(struct rpc_task *task) · 11 unmodified lines | ||
| 1865 | 1848 | |
| 1866 | 1849 | if (xprt_bound(xprt)) { |
| 1867 | 1850 | task->tk_action = call_connect; |
| 1868 | − call_connect(task); | |
| 1869 | 1851 | return; |
| 1870 | 1852 | } |
| 1871 | 1853 | |
| @@ -1896,7 +1878,6 @@ call_bind_status(struct rpc_task *task) · 24 unmodified lines | ||
| 1896 | 1878 | dprint_status(task); |
| 1897 | 1879 | task->tk_status = 0; |
| 1898 | 1880 | task->tk_action = call_connect; |
| 1899 | − call_connect(task); | |
| 1900 | 1881 | return; |
| 1901 | 1882 | } |
| 1902 | 1883 | |
| @@ -1981,7 +1962,6 @@ call_connect(struct rpc_task *task) · 78 unmodified lines | ||
| 1981 | 1962 | |
| 1982 | 1963 | if (xprt_connected(xprt)) { |
| 1983 | 1964 | task->tk_action = call_transmit; |
| 1984 | − call_transmit(task); | |
| 1985 | 1965 | return; |
| 1986 | 1966 | } |
| 1987 | 1967 | |
| @@ -2051,7 +2031,6 @@ call_connect_status(struct rpc_task *task) · 63 unmodified lines | ||
| 2051 | 2031 | case 0: |
| 2052 | 2032 | clnt->cl_stats->netreconn++; |
| 2053 | 2033 | task->tk_action = call_transmit; |
| 2054 | − call_transmit(task); | |
| 2055 | 2034 | return; |
| 2056 | 2035 | } |
| 2057 | 2036 | rpc_exit(task, status); |
| @@ -2087,9 +2066,6 @@ call_transmit(struct rpc_task *task) · 29 unmodified lines | ||
| 2087 | 2066 | xprt_transmit(task); |
| 2088 | 2067 | } |
| 2089 | 2068 | xprt_end_transmit(task); |
| 2090 | − if (rpc_task_need_resched(task)) | |
| 2091 | − return; | |
| 2092 | − call_transmit_status(task); | |
| 2093 | 2069 | } |
| 2094 | 2070 | |
| 2095 | 2071 | /* |
| @@ -2107,9 +2083,6 @@ call_transmit_status(struct rpc_task *task) · 11 unmodified lines | ||
| 2107 | 2083 | if (rpc_task_transmitted(task)) { |
| 2108 | 2084 | if (task->tk_status == 0) |
| 2109 | 2085 | xprt_request_wait_receive(task); |
| 2110 | − if (rpc_task_need_resched(task)) | |
| 2111 | − return; | |
| 2112 | − call_status(task); | |
| 2113 | 2086 | return; |
| 2114 | 2087 | } |
| 2115 | 2088 | |
| @@ -2170,7 +2143,6 @@ call_bc_encode(struct rpc_task *task) · 54 unmodified lines | ||
| 2170 | 2143 | { |
| 2171 | 2144 | xprt_request_enqueue_transmit(task); |
| 2172 | 2145 | task->tk_action = call_bc_transmit; |
| 2173 | − call_bc_transmit(task); | |
| 2174 | 2146 | } |
| 2175 | 2147 | |
| 2176 | 2148 | /* |
| @@ -2261,7 +2233,6 @@ call_status(struct rpc_task *task) · 84 unmodified lines | ||
| 2261 | 2233 | status = task->tk_status; |
| 2262 | 2234 | if (status >= 0) { |
| 2263 | 2235 | task->tk_action = call_decode; |
| 2264 | − call_decode(task); | |
| 2265 | 2236 | return; |
| 2266 | 2237 | } |
| 2267 | 2238 | |
| @@ -90,7 +90,7 @@ static void rpcrdma_xprt_drain(struct rpcrdma_xprt *r_xprt) · 89 unmodified lines | ||
| 90 | 90 | /* Flush Receives, then wait for deferred Reply work |
| 91 | 91 | * to complete. |
| 92 | 92 | */ |
| 93 | − ib_drain_qp(ia->ri_id->qp); | |
| 93 | + ib_drain_rq(ia->ri_id->qp); | |
| 94 | 94 | drain_workqueue(buf->rb_completion_wq); |
| 95 | 95 | |
| 96 | 96 | /* Deferred Reply processing might have scheduled |
| @@ -876,6 +876,8 @@ void tipc_link_reset(struct tipc_link *l) · 875 unmodified lines | ||
| 876 | 876 | __skb_queue_head_init(&list); |
| 877 | 877 | |
| 878 | 878 | l->in_session = false; |
| 879 | + /* Force re-synch of peer session number before establishing */ | |
| 880 | + l->peer_session--; | |
| 879 | 881 | l->session++; |
| 880 | 882 | l->mtu = l->advertised_mtu; |
| 881 | 883 | |
| @@ -909,7 +909,8 @@ static int tipc_nl_service_list(struct net *net, struct tipc_nl_msg *msg, · 908 unmodified lines | ||
| 909 | 909 | for (; i < TIPC_NAMETBL_SIZE; i++) { |
| 910 | 910 | head = &tn->nametbl->services[i]; |
| 911 | 911 | |
| 912 | − if (*last_type) { | |
| 912 | + if (*last_type || | |
| 913 | + (!i && *last_key && (*last_lower == *last_key))) { | |
| 913 | 914 | service = tipc_service_find(net, *last_type); |
| 914 | 915 | if (!service) |
| 915 | 916 | return -EPIPE; |
| @@ -38,6 +38,8 @@ · 37 unmodified lines | ||
| 38 | 38 | |
| 39 | 39 | #include <linux/sysctl.h> |
| 40 | 40 | |
| 41 | +static int zero; | |
| 42 | +static int one = 1; | |
| 41 | 43 | static struct ctl_table_header *tipc_ctl_hdr; |
| 42 | 44 | |
| 43 | 45 | static struct ctl_table tipc_table[] = { |
| @@ -46,14 +48,16 @@ static struct ctl_table tipc_table[] = { · 2 unmodified lines | ||
| 46 | 48 | .data = &sysctl_tipc_rmem, |
| 47 | 49 | .maxlen = sizeof(sysctl_tipc_rmem), |
| 48 | 50 | .mode = 0644, |
| 49 | − .proc_handler = proc_dointvec, | |
| 51 | + .proc_handler = proc_dointvec_minmax, | |
| 52 | + .extra1 = &one, | |
| 50 | 53 | }, |
| 51 | 54 | { |
| 52 | 55 | .procname = "named_timeout", |
| 53 | 56 | .data = &sysctl_tipc_named_timeout, |
| 54 | 57 | .maxlen = sizeof(sysctl_tipc_named_timeout), |
| 55 | 58 | .mode = 0644, |
| 56 | − .proc_handler = proc_dointvec, | |
| 59 | + .proc_handler = proc_dointvec_minmax, | |
| 60 | + .extra1 = &zero, | |
| 57 | 61 | }, |
| 58 | 62 | { |
| 59 | 63 | .procname = "sk_filter", |
| @@ -52,8 +52,11 @@ static DEFINE_SPINLOCK(tls_device_lock); · 51 unmodified lines | ||
| 52 | 52 | |
| 53 | 53 | static void tls_device_free_ctx(struct tls_context *ctx) |
| 54 | 54 | { |
| 55 | − if (ctx->tx_conf == TLS_HW) | |
| 55 | + if (ctx->tx_conf == TLS_HW) { | |
| 56 | 56 | kfree(tls_offload_ctx_tx(ctx)); |
| 57 | + kfree(ctx->tx.rec_seq); | |
| 58 | + kfree(ctx->tx.iv); | |
| 59 | + } | |
| 57 | 60 | |
| 58 | 61 | if (ctx->rx_conf == TLS_HW) |
| 59 | 62 | kfree(tls_offload_ctx_rx(ctx)); |
| @@ -216,6 +219,13 @@ void tls_device_sk_destruct(struct sock *sk) · 156 unmodified lines | ||
| 216 | 219 | } |
| 217 | 220 | EXPORT_SYMBOL(tls_device_sk_destruct); |
| 218 | 221 | |
| 222 | +void tls_device_free_resources_tx(struct sock *sk) | |
| 223 | +{ | |
| 224 | + struct tls_context *tls_ctx = tls_get_ctx(sk); | |
| 225 | + | |
| 226 | + tls_free_partial_record(sk, tls_ctx); | |
| 227 | +} | |
| 228 | + | |
| 219 | 229 | static void tls_append_frag(struct tls_record_info *record, |
| 220 | 230 | struct page_frag *pfrag, |
| 221 | 231 | int size) |
| @@ -208,6 +208,26 @@ int tls_push_partial_record(struct sock *sk, struct tls_context *ctx, · 207 unmodified lines | ||
| 208 | 208 | return tls_push_sg(sk, ctx, sg, offset, flags); |
| 209 | 209 | } |
| 210 | 210 | |
| 211 | +bool tls_free_partial_record(struct sock *sk, struct tls_context *ctx) | |
| 212 | +{ | |
| 213 | + struct scatterlist *sg; | |
| 214 | + | |
| 215 | + sg = ctx->partially_sent_record; | |
| 216 | + if (!sg) | |
| 217 | + return false; | |
| 218 | + | |
| 219 | + while (1) { | |
| 220 | + put_page(sg_page(sg)); | |
| 221 | + sk_mem_uncharge(sk, sg->length); | |
| 222 | + | |
| 223 | + if (sg_is_last(sg)) | |
| 224 | + break; | |
| 225 | + sg++; | |
| 226 | + } | |
| 227 | + ctx->partially_sent_record = NULL; | |
| 228 | + return true; | |
| 229 | +} | |
| 230 | + | |
| 211 | 231 | static void tls_write_space(struct sock *sk) |
| 212 | 232 | { |
| 213 | 233 | struct tls_context *ctx = tls_get_ctx(sk); |
| @@ -267,6 +287,10 @@ static void tls_sk_proto_close(struct sock *sk, long timeout) · 53 unmodified lines | ||
| 267 | 287 | kfree(ctx->tx.rec_seq); |
| 268 | 288 | kfree(ctx->tx.iv); |
| 269 | 289 | tls_sw_free_resources_tx(sk); |
| 290 | +#ifdef CONFIG_TLS_DEVICE | |
| 291 | + } else if (ctx->tx_conf == TLS_HW) { | |
| 292 | + tls_device_free_resources_tx(sk); | |
| 293 | +#endif | |
| 270 | 294 | } |
| 271 | 295 | |
| 272 | 296 | if (ctx->rx_conf == TLS_SW) { |
| @@ -2065,20 +2065,7 @@ void tls_sw_free_resources_tx(struct sock *sk) · 2064 unmodified lines | ||
| 2065 | 2065 | /* Free up un-sent records in tx_list. First, free |
| 2066 | 2066 | * the partially sent record if any at head of tx_list. |
| 2067 | 2067 | */ |
| 2068 | − if (tls_ctx->partially_sent_record) { | |
| 2069 | − struct scatterlist *sg = tls_ctx->partially_sent_record; | |
| 2070 | − | |
| 2071 | − while (1) { | |
| 2072 | − put_page(sg_page(sg)); | |
| 2073 | − sk_mem_uncharge(sk, sg->length); | |
| 2074 | − | |
| 2075 | − if (sg_is_last(sg)) | |
| 2076 | − break; | |
| 2077 | − sg++; | |
| 2078 | − } | |
| 2079 | − | |
| 2080 | − tls_ctx->partially_sent_record = NULL; | |
| 2081 | − | |
| 2068 | + if (tls_free_partial_record(sk, tls_ctx)) { | |
| 2082 | 2069 | rec = list_first_entry(&ctx->tx_list, |
| 2083 | 2070 | struct tls_rec, list); |
| 2084 | 2071 | list_del(&rec->list); |
| @@ -13614,7 +13614,8 @@ static const struct genl_ops nl80211_ops[] = { · 13613 unmodified lines | ||
| 13614 | 13614 | .doit = nl80211_associate, |
| 13615 | 13615 | .flags = GENL_UNS_ADMIN_PERM, |
| 13616 | 13616 | .internal_flags = NL80211_FLAG_NEED_NETDEV_UP | |
| 13617 | − NL80211_FLAG_NEED_RTNL, | |
| 13617 | + NL80211_FLAG_NEED_RTNL | | |
| 13618 | + NL80211_FLAG_CLEAR_SKB, | |
| 13618 | 13619 | }, |
| 13619 | 13620 | { |
| 13620 | 13621 | .cmd = NL80211_CMD_DEAUTHENTICATE, |
| @@ -13659,14 +13660,16 @@ static const struct genl_ops nl80211_ops[] = { · 38 unmodified lines | ||
| 13659 | 13660 | .doit = nl80211_connect, |
| 13660 | 13661 | .flags = GENL_UNS_ADMIN_PERM, |
| 13661 | 13662 | .internal_flags = NL80211_FLAG_NEED_NETDEV_UP | |
| 13662 | − NL80211_FLAG_NEED_RTNL, | |
| 13663 | + NL80211_FLAG_NEED_RTNL | | |
| 13664 | + NL80211_FLAG_CLEAR_SKB, | |
| 13663 | 13665 | }, |
| 13664 | 13666 | { |
| 13665 | 13667 | .cmd = NL80211_CMD_UPDATE_CONNECT_PARAMS, |
| 13666 | 13668 | .doit = nl80211_update_connect_params, |
| 13667 | 13669 | .flags = GENL_ADMIN_PERM, |
| 13668 | 13670 | .internal_flags = NL80211_FLAG_NEED_NETDEV_UP | |
| 13669 | − NL80211_FLAG_NEED_RTNL, | |
| 13671 | + NL80211_FLAG_NEED_RTNL | | |
| 13672 | + NL80211_FLAG_CLEAR_SKB, | |
| 13670 | 13673 | }, |
| 13671 | 13674 | { |
| 13672 | 13675 | .cmd = NL80211_CMD_DISCONNECT, |
| @@ -13691,7 +13694,8 @@ static const struct genl_ops nl80211_ops[] = { · 18 unmodified lines | ||
| 13691 | 13694 | .doit = nl80211_setdel_pmksa, |
| 13692 | 13695 | .flags = GENL_UNS_ADMIN_PERM, |
| 13693 | 13696 | .internal_flags = NL80211_FLAG_NEED_NETDEV_UP | |
| 13694 | − NL80211_FLAG_NEED_RTNL, | |
| 13697 | + NL80211_FLAG_NEED_RTNL | | |
| 13698 | + NL80211_FLAG_CLEAR_SKB, | |
| 13695 | 13699 | }, |
| 13696 | 13700 | { |
| 13697 | 13701 | .cmd = NL80211_CMD_DEL_PMKSA, |
| @@ -13999,7 +14003,8 @@ static const struct genl_ops nl80211_ops[] = { · 301 unmodified lines | ||
| 13999 | 14003 | .dumpit = nl80211_vendor_cmd_dump, |
| 14000 | 14004 | .flags = GENL_UNS_ADMIN_PERM, |
| 14001 | 14005 | .internal_flags = NL80211_FLAG_NEED_WIPHY | |
| 14002 | − NL80211_FLAG_NEED_RTNL, | |
| 14006 | + NL80211_FLAG_NEED_RTNL | | |
| 14007 | + NL80211_FLAG_CLEAR_SKB, | |
| 14003 | 14008 | }, |
| 14004 | 14009 | { |
| 14005 | 14010 | .cmd = NL80211_CMD_SET_QOS_MAP, |
| @@ -14047,7 +14052,8 @@ static const struct genl_ops nl80211_ops[] = { · 41 unmodified lines | ||
| 14047 | 14052 | .cmd = NL80211_CMD_SET_PMK, |
| 14048 | 14053 | .doit = nl80211_set_pmk, |
| 14049 | 14054 | .internal_flags = NL80211_FLAG_NEED_NETDEV_UP | |
| 14050 | − NL80211_FLAG_NEED_RTNL, | |
| 14055 | + NL80211_FLAG_NEED_RTNL | | |
| 14056 | + NL80211_FLAG_CLEAR_SKB, | |
| 14051 | 14057 | }, |
| 14052 | 14058 | { |
| 14053 | 14059 | .cmd = NL80211_CMD_DEL_PMK, |
| @@ -1309,6 +1309,16 @@ reg_intersect_dfs_region(const enum nl80211_dfs_regions dfs_region1, · 1308 unmodified lines | ||
| 1309 | 1309 | return dfs_region1; |
| 1310 | 1310 | } |
| 1311 | 1311 | |
| 1312 | +static void reg_wmm_rules_intersect(const struct ieee80211_wmm_ac *wmm_ac1, | |
| 1313 | + const struct ieee80211_wmm_ac *wmm_ac2, | |
| 1314 | + struct ieee80211_wmm_ac *intersect) | |
| 1315 | +{ | |
| 1316 | + intersect->cw_min = max_t(u16, wmm_ac1->cw_min, wmm_ac2->cw_min); | |
| 1317 | + intersect->cw_max = max_t(u16, wmm_ac1->cw_max, wmm_ac2->cw_max); | |
| 1318 | + intersect->cot = min_t(u16, wmm_ac1->cot, wmm_ac2->cot); | |
| 1319 | + intersect->aifsn = max_t(u8, wmm_ac1->aifsn, wmm_ac2->aifsn); | |
| 1320 | +} | |
| 1321 | + | |
| 1312 | 1322 | /* |
| 1313 | 1323 | * Helper for regdom_intersect(), this does the real |
| 1314 | 1324 | * mathematical intersection fun |
| @@ -1323,6 +1333,8 @@ static int reg_rules_intersect(const struct ieee80211_regdomain *rd1, · 8 unmodified lines | ||
| 1323 | 1333 | struct ieee80211_freq_range *freq_range; |
| 1324 | 1334 | const struct ieee80211_power_rule *power_rule1, *power_rule2; |
| 1325 | 1335 | struct ieee80211_power_rule *power_rule; |
| 1336 | + const struct ieee80211_wmm_rule *wmm_rule1, *wmm_rule2; | |
| 1337 | + struct ieee80211_wmm_rule *wmm_rule; | |
| 1326 | 1338 | u32 freq_diff, max_bandwidth1, max_bandwidth2; |
| 1327 | 1339 | |
| 1328 | 1340 | freq_range1 = &rule1->freq_range; |
| @@ -1333,6 +1345,10 @@ static int reg_rules_intersect(const struct ieee80211_regdomain *rd1, · 4 unmodified lines | ||
| 1333 | 1345 | power_rule2 = &rule2->power_rule; |
| 1334 | 1346 | power_rule = &intersected_rule->power_rule; |
| 1335 | 1347 | |
| 1348 | + wmm_rule1 = &rule1->wmm_rule; | |
| 1349 | + wmm_rule2 = &rule2->wmm_rule; | |
| 1350 | + wmm_rule = &intersected_rule->wmm_rule; | |
| 1351 | + | |
| 1336 | 1352 | freq_range->start_freq_khz = max(freq_range1->start_freq_khz, |
| 1337 | 1353 | freq_range2->start_freq_khz); |
| 1338 | 1354 | freq_range->end_freq_khz = min(freq_range1->end_freq_khz, |
| @@ -1376,6 +1392,29 @@ static int reg_rules_intersect(const struct ieee80211_regdomain *rd1, · 37 unmodified lines | ||
| 1376 | 1392 | intersected_rule->dfs_cac_ms = max(rule1->dfs_cac_ms, |
| 1377 | 1393 | rule2->dfs_cac_ms); |
| 1378 | 1394 | |
| 1395 | + if (rule1->has_wmm && rule2->has_wmm) { | |
| 1396 | + u8 ac; | |
| 1397 | + | |
| 1398 | + for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { | |
| 1399 | + reg_wmm_rules_intersect(&wmm_rule1->client[ac], | |
| 1400 | + &wmm_rule2->client[ac], | |
| 1401 | + &wmm_rule->client[ac]); | |
| 1402 | + reg_wmm_rules_intersect(&wmm_rule1->ap[ac], | |
| 1403 | + &wmm_rule2->ap[ac], | |
| 1404 | + &wmm_rule->ap[ac]); | |
| 1405 | + } | |
| 1406 | + | |
| 1407 | + intersected_rule->has_wmm = true; | |
| 1408 | + } else if (rule1->has_wmm) { | |
| 1409 | + *wmm_rule = *wmm_rule1; | |
| 1410 | + intersected_rule->has_wmm = true; | |
| 1411 | + } else if (rule2->has_wmm) { | |
| 1412 | + *wmm_rule = *wmm_rule2; | |
| 1413 | + intersected_rule->has_wmm = true; | |
| 1414 | + } else { | |
| 1415 | + intersected_rule->has_wmm = false; | |
| 1416 | + } | |
| 1417 | + | |
| 1379 | 1418 | if (!is_valid_reg_rule(intersected_rule)) |
| 1380 | 1419 | return -EINVAL; |
| 1381 | 1420 | |
| @@ -190,10 +190,9 @@ static size_t cfg80211_gen_new_ie(const u8 *ie, size_t ielen, · 189 unmodified lines | ||
| 190 | 190 | /* copy subelement as we need to change its content to |
| 191 | 191 | * mark an ie after it is processed. |
| 192 | 192 | */ |
| 193 | − sub_copy = kmalloc(subie_len, gfp); | |
| 193 | + sub_copy = kmemdup(subelement, subie_len, gfp); | |
| 194 | 194 | if (!sub_copy) |
| 195 | 195 | return 0; |
| 196 | − memcpy(sub_copy, subelement, subie_len); | |
| 197 | 196 | |
| 198 | 197 | pos = &new_ie[0]; |
| 199 | 198 | |
| @@ -1220,9 +1220,11 @@ static u32 cfg80211_calculate_bitrate_he(struct rate_info *rate) · 1219 unmodified lines | ||
| 1220 | 1220 | else if (rate->bw == RATE_INFO_BW_HE_RU && |
| 1221 | 1221 | rate->he_ru_alloc == NL80211_RATE_INFO_HE_RU_ALLOC_26) |
| 1222 | 1222 | result = rates_26[rate->he_gi]; |
| 1223 | − else if (WARN(1, "invalid HE MCS: bw:%d, ru:%d\n", | |
| 1224 | − rate->bw, rate->he_ru_alloc)) | |
| 1223 | + else { | |
| 1224 | + WARN(1, "invalid HE MCS: bw:%d, ru:%d\n", | |
| 1225 | + rate->bw, rate->he_ru_alloc); | |
| 1225 | 1226 | return 0; |
| 1227 | + } | |
| 1226 | 1228 | |
| 1227 | 1229 | /* now scale to the appropriate MCS */ |
| 1228 | 1230 | tmp = result; |
| @@ -1336,9 +1336,16 @@ module_param_named(path_max, aa_g_path_max, aauint, S_IRUSR); · 1335 unmodified lines | ||
| 1336 | 1336 | bool aa_g_paranoid_load = true; |
| 1337 | 1337 | module_param_named(paranoid_load, aa_g_paranoid_load, aabool, S_IRUGO); |
| 1338 | 1338 | |
| 1339 | +static int param_get_aaintbool(char *buffer, const struct kernel_param *kp); | |
| 1340 | +static int param_set_aaintbool(const char *val, const struct kernel_param *kp); | |
| 1341 | +#define param_check_aaintbool param_check_int | |
| 1342 | +static const struct kernel_param_ops param_ops_aaintbool = { | |
| 1343 | + .set = param_set_aaintbool, | |
| 1344 | + .get = param_get_aaintbool | |
| 1345 | +}; | |
| 1339 | 1346 | /* Boot time disable flag */ |
| 1340 | 1347 | static int apparmor_enabled __lsm_ro_after_init = 1; |
| 1341 | −module_param_named(enabled, apparmor_enabled, int, 0444); | |
| 1348 | +module_param_named(enabled, apparmor_enabled, aaintbool, 0444); | |
| 1342 | 1349 | |
| 1343 | 1350 | static int __init apparmor_enabled_setup(char *str) |
| 1344 | 1351 | { |
| @@ -1413,6 +1420,46 @@ static int param_get_aauint(char *buffer, const struct kernel_param *kp) · 68 unmodified lines | ||
| 1413 | 1420 | return param_get_uint(buffer, kp); |
| 1414 | 1421 | } |
| 1415 | 1422 | |
| 1423 | +/* Can only be set before AppArmor is initialized (i.e. on boot cmdline). */ | |
| 1424 | +static int param_set_aaintbool(const char *val, const struct kernel_param *kp) | |
| 1425 | +{ | |
| 1426 | + struct kernel_param kp_local; | |
| 1427 | + bool value; | |
| 1428 | + int error; | |
| 1429 | + | |
| 1430 | + if (apparmor_initialized) | |
| 1431 | + return -EPERM; | |
| 1432 | + | |
| 1433 | + /* Create local copy, with arg pointing to bool type. */ | |
| 1434 | + value = !!*((int *)kp->arg); | |
| 1435 | + memcpy(&kp_local, kp, sizeof(kp_local)); | |
| 1436 | + kp_local.arg = &value; | |
| 1437 | + | |
| 1438 | + error = param_set_bool(val, &kp_local); | |
| 1439 | + if (!error) | |
| 1440 | + *((int *)kp->arg) = *((bool *)kp_local.arg); | |
| 1441 | + return error; | |
| 1442 | +} | |
| 1443 | + | |
| 1444 | +/* | |
| 1445 | + * To avoid changing /sys/module/apparmor/parameters/enabled from Y/N to | |
| 1446 | + * 1/0, this converts the "int that is actually bool" back to bool for | |
| 1447 | + * display in the /sys filesystem, while keeping it "int" for the LSM | |
| 1448 | + * infrastructure. | |
| 1449 | + */ | |
| 1450 | +static int param_get_aaintbool(char *buffer, const struct kernel_param *kp) | |
| 1451 | +{ | |
| 1452 | + struct kernel_param kp_local; | |
| 1453 | + bool value; | |
| 1454 | + | |
| 1455 | + /* Create local copy, with arg pointing to bool type. */ | |
| 1456 | + value = !!*((int *)kp->arg); | |
| 1457 | + memcpy(&kp_local, kp, sizeof(kp_local)); | |
| 1458 | + kp_local.arg = &value; | |
| 1459 | + | |
| 1460 | + return param_get_bool(buffer, &kp_local); | |
| 1461 | +} | |
| 1462 | + | |
| 1416 | 1463 | static int param_get_audit(char *buffer, const struct kernel_param *kp) |
| 1417 | 1464 | { |
| 1418 | 1465 | if (!apparmor_enabled) |
| @@ -1252,7 +1252,7 @@ static int snd_seq_ioctl_set_client_info(struct snd_seq_client *client, · 1251 unmodified lines | ||
| 1252 | 1252 | |
| 1253 | 1253 | /* fill the info fields */ |
| 1254 | 1254 | if (client_info->name[0]) |
| 1255 | − strlcpy(client->name, client_info->name, sizeof(client->name)); | |
| 1255 | + strscpy(client->name, client_info->name, sizeof(client->name)); | |
| 1256 | 1256 | |
| 1257 | 1257 | client->filter = client_info->filter; |
| 1258 | 1258 | client->event_lost = client_info->event_lost; |
| @@ -1530,7 +1530,7 @@ static int snd_seq_ioctl_create_queue(struct snd_seq_client *client, void *arg) · 271 unmodified lines | ||
| 1530 | 1530 | /* set queue name */ |
| 1531 | 1531 | if (!info->name[0]) |
| 1532 | 1532 | snprintf(info->name, sizeof(info->name), "Queue-%d", q->queue); |
| 1533 | − strlcpy(q->name, info->name, sizeof(q->name)); | |
| 1533 | + strscpy(q->name, info->name, sizeof(q->name)); | |
| 1534 | 1534 | snd_use_lock_free(&q->use_lock); |
| 1535 | 1535 | |
| 1536 | 1536 | return 0; |
| @@ -1592,7 +1592,7 @@ static int snd_seq_ioctl_set_queue_info(struct snd_seq_client *client, · 55 unmodified lines | ||
| 1592 | 1592 | queuefree(q); |
| 1593 | 1593 | return -EPERM; |
| 1594 | 1594 | } |
| 1595 | − strlcpy(q->name, info->name, sizeof(q->name)); | |
| 1595 | + strscpy(q->name, info->name, sizeof(q->name)); | |
| 1596 | 1596 | queuefree(q); |
| 1597 | 1597 | |
| 1598 | 1598 | return 0; |
| @@ -107,7 +107,6 @@ int snd_hdac_ext_bus_init(struct hdac_bus *bus, struct device *dev, · 106 unmodified lines | ||
| 107 | 107 | INIT_LIST_HEAD(&bus->hlink_list); |
| 108 | 108 | bus->idx = idx++; |
| 109 | 109 | |
| 110 | − mutex_init(&bus->lock); | |
| 111 | 110 | bus->cmd_dma_state = true; |
| 112 | 111 | |
| 113 | 112 | return 0; |
| @@ -38,6 +38,7 @@ int snd_hdac_bus_init(struct hdac_bus *bus, struct device *dev, · 37 unmodified lines | ||
| 38 | 38 | INIT_WORK(&bus->unsol_work, snd_hdac_bus_process_unsol_events); |
| 39 | 39 | spin_lock_init(&bus->reg_lock); |
| 40 | 40 | mutex_init(&bus->cmd_mutex); |
| 41 | + mutex_init(&bus->lock); | |
| 41 | 42 | bus->irq = -1; |
| 42 | 43 | return 0; |
| 43 | 44 | } |
| @@ -69,13 +69,15 @@ void snd_hdac_display_power(struct hdac_bus *bus, unsigned int idx, bool enable) · 68 unmodified lines | ||
| 69 | 69 | |
| 70 | 70 | dev_dbg(bus->dev, "display power %s\n", |
| 71 | 71 | enable ? "enable" : "disable"); |
| 72 | + | |
| 73 | + mutex_lock(&bus->lock); | |
| 72 | 74 | if (enable) |
| 73 | 75 | set_bit(idx, &bus->display_power_status); |
| 74 | 76 | else |
| 75 | 77 | clear_bit(idx, &bus->display_power_status); |
| 76 | 78 | |
| 77 | 79 | if (!acomp || !acomp->ops) |
| 78 | − return; | |
| 80 | + goto unlock; | |
| 79 | 81 | |
| 80 | 82 | if (bus->display_power_status) { |
| 81 | 83 | if (!bus->display_power_active) { |
| @@ -92,6 +94,8 @@ void snd_hdac_display_power(struct hdac_bus *bus, unsigned int idx, bool enable) · 10 unmodified lines | ||
| 92 | 94 | bus->display_power_active = false; |
| 93 | 95 | } |
| 94 | 96 | } |
| 97 | + unlock: | |
| 98 | + mutex_unlock(&bus->lock); | |
| 95 | 99 | } |
| 96 | 100 | EXPORT_SYMBOL_GPL(snd_hdac_display_power); |
| 97 | 101 | |
| @@ -2142,6 +2142,8 @@ static struct snd_pci_quirk power_save_blacklist[] = { · 2141 unmodified lines | ||
| 2142 | 2142 | SND_PCI_QUIRK(0x8086, 0x2040, "Intel DZ77BH-55K", 0), |
| 2143 | 2143 | /* https://bugzilla.kernel.org/show_bug.cgi?id=199607 */ |
| 2144 | 2144 | SND_PCI_QUIRK(0x8086, 0x2057, "Intel NUC5i7RYB", 0), |
| 2145 | + /* https://bugs.launchpad.net/bugs/1821663 */ | |
| 2146 | + SND_PCI_QUIRK(0x8086, 0x2064, "Intel SDP 8086:2064", 0), | |
| 2145 | 2147 | /* https://bugzilla.redhat.com/show_bug.cgi?id=1520902 */ |
| 2146 | 2148 | SND_PCI_QUIRK(0x8086, 0x2068, "Intel NUC7i3BNB", 0), |
| 2147 | 2149 | /* https://bugzilla.kernel.org/show_bug.cgi?id=198611 */ |
| @@ -2150,6 +2152,8 @@ static struct snd_pci_quirk power_save_blacklist[] = { · 2 unmodified lines | ||
| 2150 | 2152 | SND_PCI_QUIRK(0x17aa, 0x367b, "Lenovo IdeaCentre B550", 0), |
| 2151 | 2153 | /* https://bugzilla.redhat.com/show_bug.cgi?id=1572975 */ |
| 2152 | 2154 | SND_PCI_QUIRK(0x17aa, 0x36a7, "Lenovo C50 All in one", 0), |
| 2155 | + /* https://bugs.launchpad.net/bugs/1821663 */ | |
| 2156 | + SND_PCI_QUIRK(0x1631, 0xe017, "Packard Bell NEC IMEDIA 5204", 0), | |
| 2153 | 2157 | {} |
| 2154 | 2158 | }; |
| 2155 | 2159 | #endif /* CONFIG_PM */ |
| @@ -1864,8 +1864,8 @@ enum { · 1863 unmodified lines | ||
| 1864 | 1864 | ALC887_FIXUP_BASS_CHMAP, |
| 1865 | 1865 | ALC1220_FIXUP_GB_DUAL_CODECS, |
| 1866 | 1866 | ALC1220_FIXUP_CLEVO_P950, |
| 1867 | − ALC1220_FIXUP_SYSTEM76_ORYP5, | |
| 1868 | − ALC1220_FIXUP_SYSTEM76_ORYP5_PINS, | |
| 1867 | + ALC1220_FIXUP_CLEVO_PB51ED, | |
| 1868 | + ALC1220_FIXUP_CLEVO_PB51ED_PINS, | |
| 1869 | 1869 | }; |
| 1870 | 1870 | |
| 1871 | 1871 | static void alc889_fixup_coef(struct hda_codec *codec, |
| @@ -2070,7 +2070,7 @@ static void alc1220_fixup_clevo_p950(struct hda_codec *codec, · 198 unmodified lines | ||
| 2070 | 2070 | static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec, |
| 2071 | 2071 | const struct hda_fixup *fix, int action); |
| 2072 | 2072 | |
| 2073 | −static void alc1220_fixup_system76_oryp5(struct hda_codec *codec, | |
| 2073 | +static void alc1220_fixup_clevo_pb51ed(struct hda_codec *codec, | |
| 2074 | 2074 | const struct hda_fixup *fix, |
| 2075 | 2075 | int action) |
| 2076 | 2076 | { |
| @@ -2322,18 +2322,18 @@ static const struct hda_fixup alc882_fixups[] = { · 245 unmodified lines | ||
| 2322 | 2322 | .type = HDA_FIXUP_FUNC, |
| 2323 | 2323 | .v.func = alc1220_fixup_clevo_p950, |
| 2324 | 2324 | }, |
| 2325 | − [ALC1220_FIXUP_SYSTEM76_ORYP5] = { | |
| 2325 | + [ALC1220_FIXUP_CLEVO_PB51ED] = { | |
| 2326 | 2326 | .type = HDA_FIXUP_FUNC, |
| 2327 | − .v.func = alc1220_fixup_system76_oryp5, | |
| 2327 | + .v.func = alc1220_fixup_clevo_pb51ed, | |
| 2328 | 2328 | }, |
| 2329 | − [ALC1220_FIXUP_SYSTEM76_ORYP5_PINS] = { | |
| 2329 | + [ALC1220_FIXUP_CLEVO_PB51ED_PINS] = { | |
| 2330 | 2330 | .type = HDA_FIXUP_PINS, |
| 2331 | 2331 | .v.pins = (const struct hda_pintbl[]) { |
| 2332 | 2332 | { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ |
| 2333 | 2333 | {} |
| 2334 | 2334 | }, |
| 2335 | 2335 | .chained = true, |
| 2336 | − .chain_id = ALC1220_FIXUP_SYSTEM76_ORYP5, | |
| 2336 | + .chain_id = ALC1220_FIXUP_CLEVO_PB51ED, | |
| 2337 | 2337 | }, |
| 2338 | 2338 | }; |
| 2339 | 2339 | |
| @@ -2411,8 +2411,9 @@ static const struct snd_pci_quirk alc882_fixup_tbl[] = { · 71 unmodified lines | ||
| 2411 | 2411 | SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950), |
| 2412 | 2412 | SND_PCI_QUIRK(0x1558, 0x95e1, "Clevo P95xER", ALC1220_FIXUP_CLEVO_P950), |
| 2413 | 2413 | SND_PCI_QUIRK(0x1558, 0x95e2, "Clevo P950ER", ALC1220_FIXUP_CLEVO_P950), |
| 2414 | − SND_PCI_QUIRK(0x1558, 0x96e1, "System76 Oryx Pro (oryp5)", ALC1220_FIXUP_SYSTEM76_ORYP5_PINS), | |
| 2415 | − SND_PCI_QUIRK(0x1558, 0x97e1, "System76 Oryx Pro (oryp5)", ALC1220_FIXUP_SYSTEM76_ORYP5_PINS), | |
| 2414 | + SND_PCI_QUIRK(0x1558, 0x96e1, "System76 Oryx Pro (oryp5)", ALC1220_FIXUP_CLEVO_PB51ED_PINS), | |
| 2415 | + SND_PCI_QUIRK(0x1558, 0x97e1, "System76 Oryx Pro (oryp5)", ALC1220_FIXUP_CLEVO_PB51ED_PINS), | |
| 2416 | + SND_PCI_QUIRK(0x1558, 0x65d1, "Tuxedo Book XC1509", ALC1220_FIXUP_CLEVO_PB51ED_PINS), | |
| 2416 | 2417 | SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD), |
| 2417 | 2418 | SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD), |
| 2418 | 2419 | SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530), |
| @@ -5491,7 +5492,7 @@ static void alc_headset_btn_callback(struct hda_codec *codec, · 3072 unmodified lines | ||
| 5491 | 5492 | jack->jack->button_state = report; |
| 5492 | 5493 | } |
| 5493 | 5494 | |
| 5494 | −static void alc295_fixup_chromebook(struct hda_codec *codec, | |
| 5495 | +static void alc_fixup_headset_jack(struct hda_codec *codec, | |
| 5495 | 5496 | const struct hda_fixup *fix, int action) |
| 5496 | 5497 | { |
| 5497 | 5498 | |
| @@ -5501,16 +5502,6 @@ static void alc295_fixup_chromebook(struct hda_codec *codec, · 3 unmodified lines | ||
| 5501 | 5502 | alc_headset_btn_callback); |
| 5502 | 5503 | snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack", false, |
| 5503 | 5504 | SND_JACK_HEADSET, alc_headset_btn_keymap); |
| 5504 | − switch (codec->core.vendor_id) { | |
| 5505 | − case 0x10ec0295: | |
| 5506 | − alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */ | |
| 5507 | − alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15); | |
| 5508 | − break; | |
| 5509 | − case 0x10ec0236: | |
| 5510 | − alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */ | |
| 5511 | − alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15); | |
| 5512 | − break; | |
| 5513 | − } | |
| 5514 | 5505 | break; |
| 5515 | 5506 | case HDA_FIXUP_ACT_INIT: |
| 5516 | 5507 | switch (codec->core.vendor_id) { |
| @@ -5531,6 +5522,25 @@ static void alc295_fixup_chromebook(struct hda_codec *codec, · 14 unmodified lines | ||
| 5531 | 5522 | } |
| 5532 | 5523 | } |
| 5533 | 5524 | |
| 5525 | +static void alc295_fixup_chromebook(struct hda_codec *codec, | |
| 5526 | + const struct hda_fixup *fix, int action) | |
| 5527 | +{ | |
| 5528 | + switch (action) { | |
| 5529 | + case HDA_FIXUP_ACT_INIT: | |
| 5530 | + switch (codec->core.vendor_id) { | |
| 5531 | + case 0x10ec0295: | |
| 5532 | + alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */ | |
| 5533 | + alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15); | |
| 5534 | + break; | |
| 5535 | + case 0x10ec0236: | |
| 5536 | + alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */ | |
| 5537 | + alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15); | |
| 5538 | + break; | |
| 5539 | + } | |
| 5540 | + break; | |
| 5541 | + } | |
| 5542 | +} | |
| 5543 | + | |
| 5534 | 5544 | static void alc_fixup_disable_mic_vref(struct hda_codec *codec, |
| 5535 | 5545 | const struct hda_fixup *fix, int action) |
| 5536 | 5546 | { |
| @@ -5663,6 +5673,7 @@ enum { · 126 unmodified lines | ||
| 5663 | 5673 | ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, |
| 5664 | 5674 | ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, |
| 5665 | 5675 | ALC233_FIXUP_LENOVO_MULTI_CODECS, |
| 5676 | + ALC233_FIXUP_ACER_HEADSET_MIC, | |
| 5666 | 5677 | ALC294_FIXUP_LENOVO_MIC_LOCATION, |
| 5667 | 5678 | ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, |
| 5668 | 5679 | ALC700_FIXUP_INTEL_REFERENCE, |
| @@ -5684,6 +5695,7 @@ enum { · 15 unmodified lines | ||
| 5684 | 5695 | ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE, |
| 5685 | 5696 | ALC255_FIXUP_ACER_HEADSET_MIC, |
| 5686 | 5697 | ALC295_FIXUP_CHROME_BOOK, |
| 5698 | + ALC225_FIXUP_HEADSET_JACK, | |
| 5687 | 5699 | ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE, |
| 5688 | 5700 | ALC225_FIXUP_WYSE_AUTO_MUTE, |
| 5689 | 5701 | ALC225_FIXUP_WYSE_DISABLE_MIC_VREF, |
| @@ -6490,6 +6502,16 @@ static const struct hda_fixup alc269_fixups[] = { · 800 unmodified lines | ||
| 6490 | 6502 | .type = HDA_FIXUP_FUNC, |
| 6491 | 6503 | .v.func = alc233_alc662_fixup_lenovo_dual_codecs, |
| 6492 | 6504 | }, |
| 6505 | + [ALC233_FIXUP_ACER_HEADSET_MIC] = { | |
| 6506 | + .type = HDA_FIXUP_VERBS, | |
| 6507 | + .v.verbs = (const struct hda_verb[]) { | |
| 6508 | + { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 }, | |
| 6509 | + { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 }, | |
| 6510 | + { } | |
| 6511 | + }, | |
| 6512 | + .chained = true, | |
| 6513 | + .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE | |
| 6514 | + }, | |
| 6493 | 6515 | [ALC294_FIXUP_LENOVO_MIC_LOCATION] = { |
| 6494 | 6516 | .type = HDA_FIXUP_PINS, |
| 6495 | 6517 | .v.pins = (const struct hda_pintbl[]) { |
| @@ -6635,6 +6657,12 @@ static const struct hda_fixup alc269_fixups[] = { · 139 unmodified lines | ||
| 6635 | 6657 | [ALC295_FIXUP_CHROME_BOOK] = { |
| 6636 | 6658 | .type = HDA_FIXUP_FUNC, |
| 6637 | 6659 | .v.func = alc295_fixup_chromebook, |
| 6660 | + .chained = true, | |
| 6661 | + .chain_id = ALC225_FIXUP_HEADSET_JACK | |
| 6662 | + }, | |
| 6663 | + [ALC225_FIXUP_HEADSET_JACK] = { | |
| 6664 | + .type = HDA_FIXUP_FUNC, | |
| 6665 | + .v.func = alc_fixup_headset_jack, | |
| 6638 | 6666 | }, |
| 6639 | 6667 | [ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = { |
| 6640 | 6668 | .type = HDA_FIXUP_PINS, |
| @@ -6737,6 +6765,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { · 96 unmodified lines | ||
| 6737 | 6765 | SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC), |
| 6738 | 6766 | SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC), |
| 6739 | 6767 | SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC), |
| 6768 | + SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC), | |
| 6740 | 6769 | SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC), |
| 6741 | 6770 | SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z), |
| 6742 | 6771 | SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS), |
| @@ -7132,7 +7161,8 @@ static const struct hda_model_fixup alc269_fixup_models[] = { · 389 unmodified lines | ||
| 7132 | 7161 | {.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"}, |
| 7133 | 7162 | {.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"}, |
| 7134 | 7163 | {.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"}, |
| 7135 | − {.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-sense-combo"}, | |
| 7164 | + {.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-headset-jack"}, | |
| 7165 | + {.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-chrome-book"}, | |
| 7136 | 7166 | {.id = ALC299_FIXUP_PREDATOR_SPK, .name = "predator-spk"}, |
| 7137 | 7167 | {} |
| 7138 | 7168 | }; |
| @@ -1151,6 +1151,7 @@ config SND_SOC_WCD9335 · 1150 unmodified lines | ||
| 1151 | 1151 | tristate "WCD9335 Codec" |
| 1152 | 1152 | depends on SLIMBUS |
| 1153 | 1153 | select REGMAP_SLIMBUS |
| 1154 | + select REGMAP_IRQ | |
| 1154 | 1155 | help |
| 1155 | 1156 | The WCD9335 is a standalone Hi-Fi audio CODEC IC, supports |
| 1156 | 1157 | Qualcomm Technologies, Inc. (QTI) multimedia solutions, |
| @@ -2129,6 +2129,7 @@ static int ab8500_codec_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt) · 2128 unmodified lines | ||
| 2129 | 2129 | dev_err(dai->component->dev, |
| 2130 | 2130 | "%s: ERROR: The device is either a master or a slave.\n", |
| 2131 | 2131 | __func__); |
| 2132 | + /* fall through */ | |
| 2132 | 2133 | default: |
| 2133 | 2134 | dev_err(dai->component->dev, |
| 2134 | 2135 | "%s: ERROR: Unsupporter master mask 0x%x\n", |
| @@ -1635,6 +1635,16 @@ err: · 1634 unmodified lines | ||
| 1635 | 1635 | return ret; |
| 1636 | 1636 | } |
| 1637 | 1637 | |
| 1638 | +static int cs35l35_i2c_remove(struct i2c_client *i2c_client) | |
| 1639 | +{ | |
| 1640 | + struct cs35l35_private *cs35l35 = i2c_get_clientdata(i2c_client); | |
| 1641 | + | |
| 1642 | + regulator_bulk_disable(cs35l35->num_supplies, cs35l35->supplies); | |
| 1643 | + gpiod_set_value_cansleep(cs35l35->reset_gpio, 0); | |
| 1644 | + | |
| 1645 | + return 0; | |
| 1646 | +} | |
| 1647 | + | |
| 1638 | 1648 | static const struct of_device_id cs35l35_of_match[] = { |
| 1639 | 1649 | {.compatible = "cirrus,cs35l35"}, |
| 1640 | 1650 | {}, |
| @@ -1655,6 +1665,7 @@ static struct i2c_driver cs35l35_i2c_driver = { · 14 unmodified lines | ||
| 1655 | 1665 | }, |
| 1656 | 1666 | .id_table = cs35l35_id, |
| 1657 | 1667 | .probe = cs35l35_i2c_probe, |
| 1668 | + .remove = cs35l35_i2c_remove, | |
| 1658 | 1669 | }; |
| 1659 | 1670 | |
| 1660 | 1671 | module_i2c_driver(cs35l35_i2c_driver); |
| @@ -642,6 +642,7 @@ static const struct regmap_config cs4270_regmap = { · 641 unmodified lines | ||
| 642 | 642 | .reg_defaults = cs4270_reg_defaults, |
| 643 | 643 | .num_reg_defaults = ARRAY_SIZE(cs4270_reg_defaults), |
| 644 | 644 | .cache_type = REGCACHE_RBTREE, |
| 645 | + .write_flag_mask = CS4270_I2C_INCR, | |
| 645 | 646 | |
| 646 | 647 | .readable_reg = cs4270_reg_is_readable, |
| 647 | 648 | .volatile_reg = cs4270_reg_is_volatile, |
| @@ -38,6 +38,9 @@ static void hdac_hda_dai_close(struct snd_pcm_substream *substream, · 37 unmodified lines | ||
| 38 | 38 | struct snd_soc_dai *dai); |
| 39 | 39 | static int hdac_hda_dai_prepare(struct snd_pcm_substream *substream, |
| 40 | 40 | struct snd_soc_dai *dai); |
| 41 | +static int hdac_hda_dai_hw_params(struct snd_pcm_substream *substream, | |
| 42 | + struct snd_pcm_hw_params *params, | |
| 43 | + struct snd_soc_dai *dai); | |
| 41 | 44 | static int hdac_hda_dai_hw_free(struct snd_pcm_substream *substream, |
| 42 | 45 | struct snd_soc_dai *dai); |
| 43 | 46 | static int hdac_hda_dai_set_tdm_slot(struct snd_soc_dai *dai, |
| @@ -50,6 +53,7 @@ static const struct snd_soc_dai_ops hdac_hda_dai_ops = { · 6 unmodified lines | ||
| 50 | 53 | .startup = hdac_hda_dai_open, |
| 51 | 54 | .shutdown = hdac_hda_dai_close, |
| 52 | 55 | .prepare = hdac_hda_dai_prepare, |
| 56 | + .hw_params = hdac_hda_dai_hw_params, | |
| 53 | 57 | .hw_free = hdac_hda_dai_hw_free, |
| 54 | 58 | .set_tdm_slot = hdac_hda_dai_set_tdm_slot, |
| 55 | 59 | }; |
| @@ -139,6 +143,39 @@ static int hdac_hda_dai_set_tdm_slot(struct snd_soc_dai *dai, · 83 unmodified lines | ||
| 139 | 143 | return 0; |
| 140 | 144 | } |
| 141 | 145 | |
| 146 | +static int hdac_hda_dai_hw_params(struct snd_pcm_substream *substream, | |
| 147 | + struct snd_pcm_hw_params *params, | |
| 148 | + struct snd_soc_dai *dai) | |
| 149 | +{ | |
| 150 | + struct snd_soc_component *component = dai->component; | |
| 151 | + struct hdac_hda_priv *hda_pvt; | |
| 152 | + unsigned int format_val; | |
| 153 | + unsigned int maxbps; | |
| 154 | + | |
| 155 | + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) | |
| 156 | + maxbps = dai->driver->playback.sig_bits; | |
| 157 | + else | |
| 158 | + maxbps = dai->driver->capture.sig_bits; | |
| 159 | + | |
| 160 | + hda_pvt = snd_soc_component_get_drvdata(component); | |
| 161 | + format_val = snd_hdac_calc_stream_format(params_rate(params), | |
| 162 | + params_channels(params), | |
| 163 | + params_format(params), | |
| 164 | + maxbps, | |
| 165 | + 0); | |
| 166 | + if (!format_val) { | |
| 167 | + dev_err(dai->dev, | |
| 168 | + "invalid format_val, rate=%d, ch=%d, format=%d, maxbps=%d\n", | |
| 169 | + params_rate(params), params_channels(params), | |
| 170 | + params_format(params), maxbps); | |
| 171 | + | |
| 172 | + return -EINVAL; | |
| 173 | + } | |
| 174 | + | |
| 175 | + hda_pvt->pcm[dai->id].format_val[substream->stream] = format_val; | |
| 176 | + return 0; | |
| 177 | +} | |
| 178 | + | |
| 142 | 179 | static int hdac_hda_dai_hw_free(struct snd_pcm_substream *substream, |
| 143 | 180 | struct snd_soc_dai *dai) |
| 144 | 181 | { |
| @@ -162,10 +199,9 @@ static int hdac_hda_dai_prepare(struct snd_pcm_substream *substream, · 17 unmodified lines | ||
| 162 | 199 | struct snd_soc_dai *dai) |
| 163 | 200 | { |
| 164 | 201 | struct snd_soc_component *component = dai->component; |
| 202 | + struct hda_pcm_stream *hda_stream; | |
| 165 | 203 | struct hdac_hda_priv *hda_pvt; |
| 166 | − struct snd_pcm_runtime *runtime = substream->runtime; | |
| 167 | 204 | struct hdac_device *hdev; |
| 168 | − struct hda_pcm_stream *hda_stream; | |
| 169 | 205 | unsigned int format_val; |
| 170 | 206 | struct hda_pcm *pcm; |
| 171 | 207 | unsigned int stream; |
| @@ -179,19 +215,8 @@ static int hdac_hda_dai_prepare(struct snd_pcm_substream *substream, · 7 unmodified lines | ||
| 179 | 215 | |
| 180 | 216 | hda_stream = &pcm->stream[substream->stream]; |
| 181 | 217 | |
| 182 | − format_val = snd_hdac_calc_stream_format(runtime->rate, | |
| 183 | − runtime->channels, | |
| 184 | − runtime->format, | |
| 185 | − hda_stream->maxbps, | |
| 186 | − 0); | |
| 187 | − if (!format_val) { | |
| 188 | − dev_err(&hdev->dev, | |
| 189 | − "invalid format_val, rate=%d, ch=%d, format=%d\n", | |
| 190 | − runtime->rate, runtime->channels, runtime->format); | |
| 191 | − return -EINVAL; | |
| 192 | − } | |
| 193 | − | |
| 194 | 218 | stream = hda_pvt->pcm[dai->id].stream_tag[substream->stream]; |
| 219 | + format_val = hda_pvt->pcm[dai->id].format_val[substream->stream]; | |
| 195 | 220 | |
| 196 | 221 | ret = snd_hda_codec_prepare(&hda_pvt->codec, hda_stream, |
| 197 | 222 | stream, format_val, substream); |
| @@ -8,6 +8,7 @@ · 7 unmodified lines | ||
| 8 | 8 | |
| 9 | 9 | struct hdac_hda_pcm { |
| 10 | 10 | int stream_tag[2]; |
| 11 | + unsigned int format_val[2]; | |
| 11 | 12 | }; |
| 12 | 13 | |
| 13 | 14 | struct hdac_hda_priv { |
| @@ -484,9 +484,6 @@ static int hdmi_codec_hw_params(struct snd_pcm_substream *substream, · 483 unmodified lines | ||
| 484 | 484 | params_width(params), params_rate(params), |
| 485 | 485 | params_channels(params)); |
| 486 | 486 | |
| 487 | − if (params_width(params) > 24) | |
| 488 | − params->msbits = 24; | |
| 489 | − | |
| 490 | 487 | ret = snd_pcm_create_iec958_consumer_hw_params(params, hp.iec.status, |
| 491 | 488 | sizeof(hp.iec.status)); |
| 492 | 489 | if (ret < 0) { |
| @@ -529,73 +526,71 @@ static int hdmi_codec_set_fmt(struct snd_soc_dai *dai, · 36 unmodified lines | ||
| 529 | 526 | { |
| 530 | 527 | struct hdmi_codec_priv *hcp = snd_soc_dai_get_drvdata(dai); |
| 531 | 528 | struct hdmi_codec_daifmt cf = { 0 }; |
| 532 | − int ret = 0; | |
| 533 | 529 | |
| 534 | 530 | dev_dbg(dai->dev, "%s()\n", __func__); |
| 535 | 531 | |
| 536 | − if (dai->id == DAI_ID_SPDIF) { | |
| 537 | − cf.fmt = HDMI_SPDIF; | |
| 538 | − } else { | |
| 539 | − switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { | |
| 540 | − case SND_SOC_DAIFMT_CBM_CFM: | |
| 541 | − cf.bit_clk_master = 1; | |
| 542 | − cf.frame_clk_master = 1; | |
| 543 | − break; | |
| 544 | − case SND_SOC_DAIFMT_CBS_CFM: | |
| 545 | − cf.frame_clk_master = 1; | |
| 546 | − break; | |
| 547 | − case SND_SOC_DAIFMT_CBM_CFS: | |
| 548 | − cf.bit_clk_master = 1; | |
| 549 | − break; | |
| 550 | − case SND_SOC_DAIFMT_CBS_CFS: | |
| 551 | − break; | |
| 552 | − default: | |
| 553 | − return -EINVAL; | |
| 554 | − } | |
| 532 | + if (dai->id == DAI_ID_SPDIF) | |
| 533 | + return 0; | |
| 534 | + | |
| 535 | + switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { | |
| 536 | + case SND_SOC_DAIFMT_CBM_CFM: | |
| 537 | + cf.bit_clk_master = 1; | |
| 538 | + cf.frame_clk_master = 1; | |
| 539 | + break; | |
| 540 | + case SND_SOC_DAIFMT_CBS_CFM: | |
| 541 | + cf.frame_clk_master = 1; | |
| 542 | + break; | |
| 543 | + case SND_SOC_DAIFMT_CBM_CFS: | |
| 544 | + cf.bit_clk_master = 1; | |
| 545 | + break; | |
| 546 | + case SND_SOC_DAIFMT_CBS_CFS: | |
| 547 | + break; | |
| 548 | + default: | |
| 549 | + return -EINVAL; | |
| 550 | + } | |
| 555 | 551 | |
| 556 | − switch (fmt & SND_SOC_DAIFMT_INV_MASK) { | |
| 557 | − case SND_SOC_DAIFMT_NB_NF: | |
| 558 | − break; | |
| 559 | − case SND_SOC_DAIFMT_NB_IF: | |
| 560 | − cf.frame_clk_inv = 1; | |
| 561 | − break; | |
| 562 | − case SND_SOC_DAIFMT_IB_NF: | |
| 563 | − cf.bit_clk_inv = 1; | |
| 564 | − break; | |
| 565 | − case SND_SOC_DAIFMT_IB_IF: | |
| 566 | − cf.frame_clk_inv = 1; | |
| 567 | − cf.bit_clk_inv = 1; | |
| 568 | − break; | |
| 569 | − } | |
| 552 | + switch (fmt & SND_SOC_DAIFMT_INV_MASK) { | |
| 553 | + case SND_SOC_DAIFMT_NB_NF: | |
| 554 | + break; | |
| 555 | + case SND_SOC_DAIFMT_NB_IF: | |
| 556 | + cf.frame_clk_inv = 1; | |
| 557 | + break; | |
| 558 | + case SND_SOC_DAIFMT_IB_NF: | |
| 559 | + cf.bit_clk_inv = 1; | |
| 560 | + break; | |
| 561 | + case SND_SOC_DAIFMT_IB_IF: | |
| 562 | + cf.frame_clk_inv = 1; | |
| 563 | + cf.bit_clk_inv = 1; | |
| 564 | + break; | |
| 565 | + } | |
| 570 | 566 | |
| 571 | − switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { | |
| 572 | − case SND_SOC_DAIFMT_I2S: | |
| 573 | − cf.fmt = HDMI_I2S; | |
| 574 | − break; | |
| 575 | − case SND_SOC_DAIFMT_DSP_A: | |
| 576 | − cf.fmt = HDMI_DSP_A; | |
| 577 | − break; | |
| 578 | − case SND_SOC_DAIFMT_DSP_B: | |
| 579 | − cf.fmt = HDMI_DSP_B; | |
| 580 | − break; | |
| 581 | − case SND_SOC_DAIFMT_RIGHT_J: | |
| 582 | − cf.fmt = HDMI_RIGHT_J; | |
| 583 | − break; | |
| 584 | − case SND_SOC_DAIFMT_LEFT_J: | |
| 585 | − cf.fmt = HDMI_LEFT_J; | |
| 586 | − break; | |
| 587 | − case SND_SOC_DAIFMT_AC97: | |
| 588 | − cf.fmt = HDMI_AC97; | |
| 589 | − break; | |
| 590 | − default: | |
| 591 | − dev_err(dai->dev, "Invalid DAI interface format\n"); | |
| 592 | − return -EINVAL; | |
| 593 | − } | |
| 567 | + switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { | |
| 568 | + case SND_SOC_DAIFMT_I2S: | |
| 569 | + cf.fmt = HDMI_I2S; | |
| 570 | + break; | |
| 571 | + case SND_SOC_DAIFMT_DSP_A: | |
| 572 | + cf.fmt = HDMI_DSP_A; | |
| 573 | + break; | |
| 574 | + case SND_SOC_DAIFMT_DSP_B: | |
| 575 | + cf.fmt = HDMI_DSP_B; | |
| 576 | + break; | |
| 577 | + case SND_SOC_DAIFMT_RIGHT_J: | |
| 578 | + cf.fmt = HDMI_RIGHT_J; | |
| 579 | + break; | |
| 580 | + case SND_SOC_DAIFMT_LEFT_J: | |
| 581 | + cf.fmt = HDMI_LEFT_J; | |
| 582 | + break; | |
| 583 | + case SND_SOC_DAIFMT_AC97: | |
| 584 | + cf.fmt = HDMI_AC97; | |
| 585 | + break; | |
| 586 | + default: | |
| 587 | + dev_err(dai->dev, "Invalid DAI interface format\n"); | |
| 588 | + return -EINVAL; | |
| 594 | 589 | } |
| 595 | 590 | |
| 596 | 591 | hcp->daifmt[dai->id] = cf; |
| 597 | 592 | |
| 598 | − return ret; | |
| 593 | + return 0; | |
| 599 | 594 | } |
| 600 | 595 | |
| 601 | 596 | static int hdmi_codec_digital_mute(struct snd_soc_dai *dai, int mute) |
| @@ -792,8 +787,10 @@ static int hdmi_codec_probe(struct platform_device *pdev) · 190 unmodified lines | ||
| 792 | 787 | i++; |
| 793 | 788 | } |
| 794 | 789 | |
| 795 | − if (hcd->spdif) | |
| 790 | + if (hcd->spdif) { | |
| 796 | 791 | hcp->daidrv[i] = hdmi_spdif_dai; |
| 792 | + hcp->daifmt[DAI_ID_SPDIF].fmt = HDMI_SPDIF; | |
| 793 | + } | |
| 797 | 794 | |
| 798 | 795 | dev_set_drvdata(dev, hcp); |
| 799 | 796 | |
| @@ -411,9 +411,9 @@ static const struct snd_soc_dapm_widget nau8810_dapm_widgets[] = { · 410 unmodified lines | ||
| 411 | 411 | SND_SOC_DAPM_MIXER("Mono Mixer", NAU8810_REG_POWER3, |
| 412 | 412 | NAU8810_MOUTMX_EN_SFT, 0, &nau8810_mono_mixer_controls[0], |
| 413 | 413 | ARRAY_SIZE(nau8810_mono_mixer_controls)), |
| 414 | − SND_SOC_DAPM_DAC("DAC", "HiFi Playback", NAU8810_REG_POWER3, | |
| 414 | + SND_SOC_DAPM_DAC("DAC", "Playback", NAU8810_REG_POWER3, | |
| 415 | 415 | NAU8810_DAC_EN_SFT, 0), |
| 416 | − SND_SOC_DAPM_ADC("ADC", "HiFi Capture", NAU8810_REG_POWER2, | |
| 416 | + SND_SOC_DAPM_ADC("ADC", "Capture", NAU8810_REG_POWER2, | |
| 417 | 417 | NAU8810_ADC_EN_SFT, 0), |
| 418 | 418 | SND_SOC_DAPM_PGA("SpkN Out", NAU8810_REG_POWER3, |
| 419 | 419 | NAU8810_NSPK_EN_SFT, 0, NULL, 0), |
| @@ -681,8 +681,8 @@ static const struct snd_soc_dapm_widget nau8824_dapm_widgets[] = { · 680 unmodified lines | ||
| 681 | 681 | SND_SOC_DAPM_ADC("ADCR", NULL, NAU8824_REG_ANALOG_ADC_2, |
| 682 | 682 | NAU8824_ADCR_EN_SFT, 0), |
| 683 | 683 | |
| 684 | − SND_SOC_DAPM_AIF_OUT("AIFTX", "HiFi Capture", 0, SND_SOC_NOPM, 0, 0), | |
| 685 | − SND_SOC_DAPM_AIF_IN("AIFRX", "HiFi Playback", 0, SND_SOC_NOPM, 0, 0), | |
| 684 | + SND_SOC_DAPM_AIF_OUT("AIFTX", "Capture", 0, SND_SOC_NOPM, 0, 0), | |
| 685 | + SND_SOC_DAPM_AIF_IN("AIFRX", "Playback", 0, SND_SOC_NOPM, 0, 0), | |
| 686 | 686 | |
| 687 | 687 | SND_SOC_DAPM_DAC("DACL", NULL, NAU8824_REG_RDAC, |
| 688 | 688 | NAU8824_DACL_EN_SFT, 0), |
| @@ -831,6 +831,36 @@ static void nau8824_int_status_clear_all(struct regmap *regmap) · 142 unmodified lines | ||
| 831 | 831 | } |
| 832 | 832 | } |
| 833 | 833 | |
| 834 | +static void nau8824_dapm_disable_pin(struct nau8824 *nau8824, const char *pin) | |
| 835 | +{ | |
| 836 | + struct snd_soc_dapm_context *dapm = nau8824->dapm; | |
| 837 | + const char *prefix = dapm->component->name_prefix; | |
| 838 | + char prefixed_pin[80]; | |
| 839 | + | |
| 840 | + if (prefix) { | |
| 841 | + snprintf(prefixed_pin, sizeof(prefixed_pin), "%s %s", | |
| 842 | + prefix, pin); | |
| 843 | + snd_soc_dapm_disable_pin(dapm, prefixed_pin); | |
| 844 | + } else { | |
| 845 | + snd_soc_dapm_disable_pin(dapm, pin); | |
| 846 | + } | |
| 847 | +} | |
| 848 | + | |
| 849 | +static void nau8824_dapm_enable_pin(struct nau8824 *nau8824, const char *pin) | |
| 850 | +{ | |
| 851 | + struct snd_soc_dapm_context *dapm = nau8824->dapm; | |
| 852 | + const char *prefix = dapm->component->name_prefix; | |
| 853 | + char prefixed_pin[80]; | |
| 854 | + | |
| 855 | + if (prefix) { | |
| 856 | + snprintf(prefixed_pin, sizeof(prefixed_pin), "%s %s", | |
| 857 | + prefix, pin); | |
| 858 | + snd_soc_dapm_force_enable_pin(dapm, prefixed_pin); | |
| 859 | + } else { | |
| 860 | + snd_soc_dapm_force_enable_pin(dapm, pin); | |
| 861 | + } | |
| 862 | +} | |
| 863 | + | |
| 834 | 864 | static void nau8824_eject_jack(struct nau8824 *nau8824) |
| 835 | 865 | { |
| 836 | 866 | struct snd_soc_dapm_context *dapm = nau8824->dapm; |
| @@ -839,8 +869,8 @@ static void nau8824_eject_jack(struct nau8824 *nau8824) · 2 unmodified lines | ||
| 839 | 869 | /* Clear all interruption status */ |
| 840 | 870 | nau8824_int_status_clear_all(regmap); |
| 841 | 871 | |
| 842 | − snd_soc_dapm_disable_pin(dapm, "SAR"); | |
| 843 | − snd_soc_dapm_disable_pin(dapm, "MICBIAS"); | |
| 872 | + nau8824_dapm_disable_pin(nau8824, "SAR"); | |
| 873 | + nau8824_dapm_disable_pin(nau8824, "MICBIAS"); | |
| 844 | 874 | snd_soc_dapm_sync(dapm); |
| 845 | 875 | |
| 846 | 876 | /* Enable the insertion interruption, disable the ejection |
| @@ -870,8 +900,8 @@ static void nau8824_jdet_work(struct work_struct *work) · 23 unmodified lines | ||
| 870 | 900 | struct regmap *regmap = nau8824->regmap; |
| 871 | 901 | int adc_value, event = 0, event_mask = 0; |
| 872 | 902 | |
| 873 | − snd_soc_dapm_force_enable_pin(dapm, "MICBIAS"); | |
| 874 | − snd_soc_dapm_force_enable_pin(dapm, "SAR"); | |
| 903 | + nau8824_dapm_enable_pin(nau8824, "MICBIAS"); | |
| 904 | + nau8824_dapm_enable_pin(nau8824, "SAR"); | |
| 875 | 905 | snd_soc_dapm_sync(dapm); |
| 876 | 906 | |
| 877 | 907 | msleep(100); |
| @@ -882,8 +912,8 @@ static void nau8824_jdet_work(struct work_struct *work) · 4 unmodified lines | ||
| 882 | 912 | if (adc_value < HEADSET_SARADC_THD) { |
| 883 | 913 | event |= SND_JACK_HEADPHONE; |
| 884 | 914 | |
| 885 | − snd_soc_dapm_disable_pin(dapm, "SAR"); | |
| 886 | − snd_soc_dapm_disable_pin(dapm, "MICBIAS"); | |
| 915 | + nau8824_dapm_disable_pin(nau8824, "SAR"); | |
| 916 | + nau8824_dapm_disable_pin(nau8824, "MICBIAS"); | |
| 887 | 917 | snd_soc_dapm_sync(dapm); |
| 888 | 918 | } else { |
| 889 | 919 | event |= SND_JACK_HEADSET; |
| @@ -910,13 +910,21 @@ static int rt5682_headset_detect(struct snd_soc_component *component, · 909 unmodified lines | ||
| 910 | 910 | int jack_insert) |
| 911 | 911 | { |
| 912 | 912 | struct rt5682_priv *rt5682 = snd_soc_component_get_drvdata(component); |
| 913 | − struct snd_soc_dapm_context *dapm = | |
| 914 | − snd_soc_component_get_dapm(component); | |
| 915 | 913 | unsigned int val, count; |
| 916 | 914 | |
| 917 | 915 | if (jack_insert) { |
| 918 | − snd_soc_dapm_force_enable_pin(dapm, "CBJ Power"); | |
| 919 | − snd_soc_dapm_sync(dapm); | |
| 916 | + | |
| 917 | + snd_soc_component_update_bits(component, RT5682_PWR_ANLG_1, | |
| 918 | + RT5682_PWR_VREF2 | RT5682_PWR_MB, | |
| 919 | + RT5682_PWR_VREF2 | RT5682_PWR_MB); | |
| 920 | + snd_soc_component_update_bits(component, | |
| 921 | + RT5682_PWR_ANLG_1, RT5682_PWR_FV2, 0); | |
| 922 | + usleep_range(15000, 20000); | |
| 923 | + snd_soc_component_update_bits(component, | |
| 924 | + RT5682_PWR_ANLG_1, RT5682_PWR_FV2, RT5682_PWR_FV2); | |
| 925 | + snd_soc_component_update_bits(component, RT5682_PWR_ANLG_3, | |
| 926 | + RT5682_PWR_CBJ, RT5682_PWR_CBJ); | |
| 927 | + | |
| 920 | 928 | snd_soc_component_update_bits(component, RT5682_CBJ_CTRL_1, |
| 921 | 929 | RT5682_TRIG_JD_MASK, RT5682_TRIG_JD_HIGH); |
| 922 | 930 | |
| @@ -944,8 +952,10 @@ static int rt5682_headset_detect(struct snd_soc_component *component, · 21 unmodified lines | ||
| 944 | 952 | rt5682_enable_push_button_irq(component, false); |
| 945 | 953 | snd_soc_component_update_bits(component, RT5682_CBJ_CTRL_1, |
| 946 | 954 | RT5682_TRIG_JD_MASK, RT5682_TRIG_JD_LOW); |
| 947 | − snd_soc_dapm_disable_pin(dapm, "CBJ Power"); | |
| 948 | − snd_soc_dapm_sync(dapm); | |
| 955 | + snd_soc_component_update_bits(component, RT5682_PWR_ANLG_1, | |
| 956 | + RT5682_PWR_VREF2 | RT5682_PWR_MB, 0); | |
| 957 | + snd_soc_component_update_bits(component, RT5682_PWR_ANLG_3, | |
| 958 | + RT5682_PWR_CBJ, 0); | |
| 949 | 959 | |
| 950 | 960 | rt5682->jack_type = 0; |
| 951 | 961 | } |
| @@ -1198,7 +1208,7 @@ static int set_filter_clk(struct snd_soc_dapm_widget *w, · 246 unmodified lines | ||
| 1198 | 1208 | struct snd_soc_component *component = |
| 1199 | 1209 | snd_soc_dapm_to_component(w->dapm); |
| 1200 | 1210 | struct rt5682_priv *rt5682 = snd_soc_component_get_drvdata(component); |
| 1201 | − int ref, val, reg, sft, mask, idx = -EINVAL; | |
| 1211 | + int ref, val, reg, idx = -EINVAL; | |
| 1202 | 1212 | static const int div_f[] = {1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48}; |
| 1203 | 1213 | static const int div_o[] = {1, 2, 4, 6, 8, 12, 16, 24, 32, 48}; |
| 1204 | 1214 | |
| @@ -1212,15 +1222,10 @@ static int set_filter_clk(struct snd_soc_dapm_widget *w, · 7 unmodified lines | ||
| 1212 | 1222 | |
| 1213 | 1223 | idx = rt5682_div_sel(rt5682, ref, div_f, ARRAY_SIZE(div_f)); |
| 1214 | 1224 | |
| 1215 | − if (w->shift == RT5682_PWR_ADC_S1F_BIT) { | |
| 1225 | + if (w->shift == RT5682_PWR_ADC_S1F_BIT) | |
| 1216 | 1226 | reg = RT5682_PLL_TRACK_3; |
| 1217 | − sft = RT5682_ADC_OSR_SFT; | |
| 1218 | − mask = RT5682_ADC_OSR_MASK; | |
| 1219 | − } else { | |
| 1227 | + else | |
| 1220 | 1228 | reg = RT5682_PLL_TRACK_2; |
| 1221 | − sft = RT5682_DAC_OSR_SFT; | |
| 1222 | − mask = RT5682_DAC_OSR_MASK; | |
| 1223 | − } | |
| 1224 | 1229 | |
| 1225 | 1230 | snd_soc_component_update_bits(component, reg, |
| 1226 | 1231 | RT5682_FILTER_CLK_DIV_MASK, idx << RT5682_FILTER_CLK_DIV_SFT); |
| @@ -1232,7 +1237,8 @@ static int set_filter_clk(struct snd_soc_dapm_widget *w, · 5 unmodified lines | ||
| 1232 | 1237 | } |
| 1233 | 1238 | |
| 1234 | 1239 | snd_soc_component_update_bits(component, RT5682_ADDA_CLK_1, |
| 1235 | − mask, idx << sft); | |
| 1240 | + RT5682_ADC_OSR_MASK | RT5682_DAC_OSR_MASK, | |
| 1241 | + (idx << RT5682_ADC_OSR_SFT) | (idx << RT5682_DAC_OSR_SFT)); | |
| 1236 | 1242 | |
| 1237 | 1243 | return 0; |
| 1238 | 1244 | } |
| @@ -1591,8 +1597,6 @@ static const struct snd_soc_dapm_widget rt5682_dapm_widgets[] = { · 352 unmodified lines | ||
| 1591 | 1597 | 0, NULL, 0), |
| 1592 | 1598 | SND_SOC_DAPM_SUPPLY("Vref1", RT5682_PWR_ANLG_1, RT5682_PWR_VREF1_BIT, 0, |
| 1593 | 1599 | rt5655_set_verf, SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU), |
| 1594 | − SND_SOC_DAPM_SUPPLY("Vref2", RT5682_PWR_ANLG_1, RT5682_PWR_VREF2_BIT, 0, | |
| 1595 | − rt5655_set_verf, SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU), | |
| 1596 | 1600 | |
| 1597 | 1601 | /* ASRC */ |
| 1598 | 1602 | SND_SOC_DAPM_SUPPLY_S("DAC STO1 ASRC", 1, RT5682_PLL_TRACK_1, |
| @@ -1627,9 +1631,6 @@ static const struct snd_soc_dapm_widget rt5682_dapm_widgets[] = { · 28 unmodified lines | ||
| 1627 | 1631 | SND_SOC_DAPM_PGA("BST1 CBJ", SND_SOC_NOPM, |
| 1628 | 1632 | 0, 0, NULL, 0), |
| 1629 | 1633 | |
| 1630 | − SND_SOC_DAPM_SUPPLY("CBJ Power", RT5682_PWR_ANLG_3, | |
| 1631 | − RT5682_PWR_CBJ_BIT, 0, NULL, 0), | |
| 1632 | − | |
| 1633 | 1634 | /* REC Mixer */ |
| 1634 | 1635 | SND_SOC_DAPM_MIXER("RECMIX1L", SND_SOC_NOPM, 0, 0, rt5682_rec1_l_mix, |
| 1635 | 1636 | ARRAY_SIZE(rt5682_rec1_l_mix)), |
| @@ -1792,17 +1793,13 @@ static const struct snd_soc_dapm_route rt5682_dapm_routes[] = { · 156 unmodified lines | ||
| 1792 | 1793 | |
| 1793 | 1794 | /*Vref*/ |
| 1794 | 1795 | {"MICBIAS1", NULL, "Vref1"}, |
| 1795 | − {"MICBIAS1", NULL, "Vref2"}, | |
| 1796 | 1796 | {"MICBIAS2", NULL, "Vref1"}, |
| 1797 | − {"MICBIAS2", NULL, "Vref2"}, | |
| 1798 | 1797 | |
| 1799 | 1798 | {"CLKDET SYS", NULL, "CLKDET"}, |
| 1800 | 1799 | |
| 1801 | 1800 | {"IN1P", NULL, "LDO2"}, |
| 1802 | 1801 | |
| 1803 | 1802 | {"BST1 CBJ", NULL, "IN1P"}, |
| 1804 | − {"BST1 CBJ", NULL, "CBJ Power"}, | |
| 1805 | − {"CBJ Power", NULL, "Vref2"}, | |
| 1806 | 1803 | |
| 1807 | 1804 | {"RECMIX1L", "CBJ Switch", "BST1 CBJ"}, |
| 1808 | 1805 | {"RECMIX1L", NULL, "RECMIX1L Power"}, |
| @@ -1912,9 +1909,7 @@ static const struct snd_soc_dapm_route rt5682_dapm_routes[] = { · 103 unmodified lines | ||
| 1912 | 1909 | {"HP Amp", NULL, "Capless"}, |
| 1913 | 1910 | {"HP Amp", NULL, "Charge Pump"}, |
| 1914 | 1911 | {"HP Amp", NULL, "CLKDET SYS"}, |
| 1915 | − {"HP Amp", NULL, "CBJ Power"}, | |
| 1916 | 1912 | {"HP Amp", NULL, "Vref1"}, |
| 1917 | − {"HP Amp", NULL, "Vref2"}, | |
| 1918 | 1913 | {"HPOL Playback", "Switch", "HP Amp"}, |
| 1919 | 1914 | {"HPOR Playback", "Switch", "HP Amp"}, |
| 1920 | 1915 | {"HPOL", NULL, "HPOL Playback"}, |
| @@ -2303,16 +2298,13 @@ static int rt5682_set_bias_level(struct snd_soc_component *component, · 382 unmodified lines | ||
| 2303 | 2298 | switch (level) { |
| 2304 | 2299 | case SND_SOC_BIAS_PREPARE: |
| 2305 | 2300 | regmap_update_bits(rt5682->regmap, RT5682_PWR_ANLG_1, |
| 2306 | − RT5682_PWR_MB | RT5682_PWR_BG, | |
| 2307 | − RT5682_PWR_MB | RT5682_PWR_BG); | |
| 2301 | + RT5682_PWR_BG, RT5682_PWR_BG); | |
| 2308 | 2302 | regmap_update_bits(rt5682->regmap, RT5682_PWR_DIG_1, |
| 2309 | 2303 | RT5682_DIG_GATE_CTRL | RT5682_PWR_LDO, |
| 2310 | 2304 | RT5682_DIG_GATE_CTRL | RT5682_PWR_LDO); |
| 2311 | 2305 | break; |
| 2312 | 2306 | |
| 2313 | 2307 | case SND_SOC_BIAS_STANDBY: |
| 2314 | − regmap_update_bits(rt5682->regmap, RT5682_PWR_ANLG_1, | |
| 2315 | − RT5682_PWR_MB, RT5682_PWR_MB); | |
| 2316 | 2308 | regmap_update_bits(rt5682->regmap, RT5682_PWR_DIG_1, |
| 2317 | 2309 | RT5682_DIG_GATE_CTRL, RT5682_DIG_GATE_CTRL); |
| 2318 | 2310 | break; |
| @@ -2320,7 +2312,7 @@ static int rt5682_set_bias_level(struct snd_soc_component *component, · 1 unmodified line | ||
| 2320 | 2312 | regmap_update_bits(rt5682->regmap, RT5682_PWR_DIG_1, |
| 2321 | 2313 | RT5682_DIG_GATE_CTRL | RT5682_PWR_LDO, 0); |
| 2322 | 2314 | regmap_update_bits(rt5682->regmap, RT5682_PWR_ANLG_1, |
| 2323 | − RT5682_PWR_MB | RT5682_PWR_BG, 0); | |
| 2315 | + RT5682_PWR_BG, 0); | |
| 2324 | 2316 | break; |
| 2325 | 2317 | |
| 2326 | 2318 | default: |
| @@ -2363,6 +2355,8 @@ static int rt5682_resume(struct snd_soc_component *component) · 36 unmodified lines | ||
| 2363 | 2355 | regcache_cache_only(rt5682->regmap, false); |
| 2364 | 2356 | regcache_sync(rt5682->regmap); |
| 2365 | 2357 | |
| 2358 | + rt5682_irq(0, rt5682); | |
| 2359 | + | |
| 2366 | 2360 | return 0; |
| 2367 | 2361 | } |
| 2368 | 2362 | #else |
| @@ -3,7 +3,7 @@ · 2 unmodified lines | ||
| 3 | 3 | * |
| 4 | 4 | * Copyright 2011 NW Digital Radio |
| 5 | 5 | * |
| 6 | − * Author: Jeremy McDermond <nh6z@nh6z.net> | |
| 6 | + * Author: Annaliese McDermond <nh6z@nh6z.net> | |
| 7 | 7 | * |
| 8 | 8 | * Based on sound/soc/codecs/wm8974 and TI driver for kernel 2.6.27. |
| 9 | 9 | * |
| @@ -72,5 +72,5 @@ static struct i2c_driver aic32x4_i2c_driver = { · 62 unmodified lines | ||
| 72 | 72 | module_i2c_driver(aic32x4_i2c_driver); |
| 73 | 73 | |
| 74 | 74 | MODULE_DESCRIPTION("ASoC TLV320AIC32x4 codec driver I2C"); |
| 75 | −MODULE_AUTHOR("Jeremy McDermond <nh6z@nh6z.net>"); | |
| 75 | +MODULE_AUTHOR("Annaliese McDermond <nh6z@nh6z.net>"); | |
| 76 | 76 | MODULE_LICENSE("GPL"); |
| @@ -3,7 +3,7 @@ · 2 unmodified lines | ||
| 3 | 3 | * |
| 4 | 4 | * Copyright 2011 NW Digital Radio |
| 5 | 5 | * |
| 6 | − * Author: Jeremy McDermond <nh6z@nh6z.net> | |
| 6 | + * Author: Annaliese McDermond <nh6z@nh6z.net> | |
| 7 | 7 | * |
| 8 | 8 | * Based on sound/soc/codecs/wm8974 and TI driver for kernel 2.6.27. |
| 9 | 9 | * |
| @@ -74,5 +74,5 @@ static struct spi_driver aic32x4_spi_driver = { · 64 unmodified lines | ||
| 74 | 74 | module_spi_driver(aic32x4_spi_driver); |
| 75 | 75 | |
| 76 | 76 | MODULE_DESCRIPTION("ASoC TLV320AIC32x4 codec driver SPI"); |
| 77 | −MODULE_AUTHOR("Jeremy McDermond <nh6z@nh6z.net>"); | |
| 77 | +MODULE_AUTHOR("Annaliese McDermond <nh6z@nh6z.net>"); | |
| 78 | 78 | MODULE_LICENSE("GPL"); |
| @@ -490,6 +490,8 @@ static const struct snd_soc_dapm_widget aic32x4_dapm_widgets[] = { · 489 unmodified lines | ||
| 490 | 490 | SND_SOC_DAPM_INPUT("IN2_R"), |
| 491 | 491 | SND_SOC_DAPM_INPUT("IN3_L"), |
| 492 | 492 | SND_SOC_DAPM_INPUT("IN3_R"), |
| 493 | + SND_SOC_DAPM_INPUT("CM_L"), | |
| 494 | + SND_SOC_DAPM_INPUT("CM_R"), | |
| 493 | 495 | }; |
| 494 | 496 | |
| 495 | 497 | static const struct snd_soc_dapm_route aic32x4_dapm_routes[] = { |
| @@ -1609,7 +1609,6 @@ static int aic3x_probe(struct snd_soc_component *component) · 1608 unmodified lines | ||
| 1609 | 1609 | struct aic3x_priv *aic3x = snd_soc_component_get_drvdata(component); |
| 1610 | 1610 | int ret, i; |
| 1611 | 1611 | |
| 1612 | − INIT_LIST_HEAD(&aic3x->list); | |
| 1613 | 1612 | aic3x->component = component; |
| 1614 | 1613 | |
| 1615 | 1614 | for (i = 0; i < ARRAY_SIZE(aic3x->supplies); i++) { |
| @@ -1873,6 +1872,7 @@ static int aic3x_i2c_probe(struct i2c_client *i2c, · 257 unmodified lines | ||
| 1873 | 1872 | if (ret != 0) |
| 1874 | 1873 | goto err_gpio; |
| 1875 | 1874 | |
| 1875 | + INIT_LIST_HEAD(&aic3x->list); | |
| 1876 | 1876 | list_add(&aic3x->list, &reset_list); |
| 1877 | 1877 | |
| 1878 | 1878 | return 0; |
| @@ -1889,6 +1889,8 @@ static int aic3x_i2c_remove(struct i2c_client *client) · 10 unmodified lines | ||
| 1889 | 1889 | { |
| 1890 | 1890 | struct aic3x_priv *aic3x = i2c_get_clientdata(client); |
| 1891 | 1891 | |
| 1892 | + list_del(&aic3x->list); | |
| 1893 | + | |
| 1892 | 1894 | if (gpio_is_valid(aic3x->gpio_reset) && |
| 1893 | 1895 | !aic3x_is_shared_reset(aic3x)) { |
| 1894 | 1896 | gpio_set_value(aic3x->gpio_reset, 0); |
| @@ -2905,6 +2905,8 @@ int wm_adsp2_event(struct snd_soc_dapm_widget *w, · 2904 unmodified lines | ||
| 2905 | 2905 | if (wm_adsp_fw[dsp->fw].num_caps != 0) |
| 2906 | 2906 | wm_adsp_buffer_free(dsp); |
| 2907 | 2907 | |
| 2908 | + dsp->fatal_error = false; | |
| 2909 | + | |
| 2908 | 2910 | mutex_unlock(&dsp->pwr_lock); |
| 2909 | 2911 | |
| 2910 | 2912 | adsp_dbg(dsp, "Execution stopped\n"); |
| @@ -3000,6 +3002,9 @@ static int wm_adsp_compr_attach(struct wm_adsp_compr *compr) · 89 unmodified lines | ||
| 3000 | 3002 | { |
| 3001 | 3003 | struct wm_adsp_compr_buf *buf = NULL, *tmp; |
| 3002 | 3004 | |
| 3005 | + if (compr->dsp->fatal_error) | |
| 3006 | + return -EINVAL; | |
| 3007 | + | |
| 3003 | 3008 | list_for_each_entry(tmp, &compr->dsp->buffer_list, list) { |
| 3004 | 3009 | if (!tmp->name || !strcmp(compr->name, tmp->name)) { |
| 3005 | 3010 | buf = tmp; |
| @@ -3535,11 +3540,11 @@ static int wm_adsp_buffer_get_error(struct wm_adsp_compr_buf *buf) · 529 unmodified lines | ||
| 3535 | 3540 | |
| 3536 | 3541 | ret = wm_adsp_buffer_read(buf, HOST_BUFFER_FIELD(error), &buf->error); |
| 3537 | 3542 | if (ret < 0) { |
| 3538 | − adsp_err(buf->dsp, "Failed to check buffer error: %d\n", ret); | |
| 3543 | + compr_err(buf, "Failed to check buffer error: %d\n", ret); | |
| 3539 | 3544 | return ret; |
| 3540 | 3545 | } |
| 3541 | 3546 | if (buf->error != 0) { |
| 3542 | − adsp_err(buf->dsp, "Buffer error occurred: %d\n", buf->error); | |
| 3547 | + compr_err(buf, "Buffer error occurred: %d\n", buf->error); | |
| 3543 | 3548 | return -EIO; |
| 3544 | 3549 | } |
| 3545 | 3550 | |
| @@ -3571,8 +3576,6 @@ int wm_adsp_compr_trigger(struct snd_compr_stream *stream, int cmd) · 25 unmodified lines | ||
| 3571 | 3576 | if (ret < 0) |
| 3572 | 3577 | break; |
| 3573 | 3578 | |
| 3574 | − wm_adsp_buffer_clear(compr->buf); | |
| 3575 | − | |
| 3576 | 3579 | /* Trigger the IRQ at one fragment of data */ |
| 3577 | 3580 | ret = wm_adsp_buffer_write(compr->buf, |
| 3578 | 3581 | HOST_BUFFER_FIELD(high_water_mark), |
| @@ -3584,6 +3587,8 @@ int wm_adsp_compr_trigger(struct snd_compr_stream *stream, int cmd) · 5 unmodified lines | ||
| 3584 | 3587 | } |
| 3585 | 3588 | break; |
| 3586 | 3589 | case SNDRV_PCM_TRIGGER_STOP: |
| 3590 | + if (wm_adsp_compr_attached(compr)) | |
| 3591 | + wm_adsp_buffer_clear(compr->buf); | |
| 3587 | 3592 | break; |
| 3588 | 3593 | default: |
| 3589 | 3594 | ret = -EINVAL; |
| @@ -3917,22 +3922,40 @@ int wm_adsp2_lock(struct wm_adsp *dsp, unsigned int lock_regions) · 327 unmodified lines | ||
| 3917 | 3922 | } |
| 3918 | 3923 | EXPORT_SYMBOL_GPL(wm_adsp2_lock); |
| 3919 | 3924 | |
| 3925 | +static void wm_adsp_fatal_error(struct wm_adsp *dsp) | |
| 3926 | +{ | |
| 3927 | + struct wm_adsp_compr *compr; | |
| 3928 | + | |
| 3929 | + dsp->fatal_error = true; | |
| 3930 | + | |
| 3931 | + list_for_each_entry(compr, &dsp->compr_list, list) { | |
| 3932 | + if (compr->stream) { | |
| 3933 | + snd_compr_stop_error(compr->stream, | |
| 3934 | + SNDRV_PCM_STATE_XRUN); | |
| 3935 | + snd_compr_fragment_elapsed(compr->stream); | |
| 3936 | + } | |
| 3937 | + } | |
| 3938 | +} | |
| 3939 | + | |
| 3920 | 3940 | irqreturn_t wm_adsp2_bus_error(struct wm_adsp *dsp) |
| 3921 | 3941 | { |
| 3922 | 3942 | unsigned int val; |
| 3923 | 3943 | struct regmap *regmap = dsp->regmap; |
| 3924 | 3944 | int ret = 0; |
| 3925 | 3945 | |
| 3946 | + mutex_lock(&dsp->pwr_lock); | |
| 3947 | + | |
| 3926 | 3948 | ret = regmap_read(regmap, dsp->base + ADSP2_LOCK_REGION_CTRL, &val); |
| 3927 | 3949 | if (ret) { |
| 3928 | 3950 | adsp_err(dsp, |
| 3929 | 3951 | "Failed to read Region Lock Ctrl register: %d\n", ret); |
| 3930 | − return IRQ_HANDLED; | |
| 3952 | + goto error; | |
| 3931 | 3953 | } |
| 3932 | 3954 | |
| 3933 | 3955 | if (val & ADSP2_WDT_TIMEOUT_STS_MASK) { |
| 3934 | 3956 | adsp_err(dsp, "watchdog timeout error\n"); |
| 3935 | 3957 | wm_adsp_stop_watchdog(dsp); |
| 3958 | + wm_adsp_fatal_error(dsp); | |
| 3936 | 3959 | } |
| 3937 | 3960 | |
| 3938 | 3961 | if (val & (ADSP2_SLAVE_ERR_MASK | ADSP2_REGION_LOCK_ERR_MASK)) { |
| @@ -3946,7 +3969,7 @@ irqreturn_t wm_adsp2_bus_error(struct wm_adsp *dsp) · 7 unmodified lines | ||
| 3946 | 3969 | adsp_err(dsp, |
| 3947 | 3970 | "Failed to read Bus Err Addr register: %d\n", |
| 3948 | 3971 | ret); |
| 3949 | − return IRQ_HANDLED; | |
| 3972 | + goto error; | |
| 3950 | 3973 | } |
| 3951 | 3974 | |
| 3952 | 3975 | adsp_err(dsp, "bus error address = 0x%x\n", |
| @@ -3959,7 +3982,7 @@ irqreturn_t wm_adsp2_bus_error(struct wm_adsp *dsp) · 6 unmodified lines | ||
| 3959 | 3982 | adsp_err(dsp, |
| 3960 | 3983 | "Failed to read Pmem Xmem Err Addr register: %d\n", |
| 3961 | 3984 | ret); |
| 3962 | − return IRQ_HANDLED; | |
| 3985 | + goto error; | |
| 3963 | 3986 | } |
| 3964 | 3987 | |
| 3965 | 3988 | adsp_err(dsp, "xmem error address = 0x%x\n", |
| @@ -3972,6 +3995,9 @@ irqreturn_t wm_adsp2_bus_error(struct wm_adsp *dsp) · 6 unmodified lines | ||
| 3972 | 3995 | regmap_update_bits(regmap, dsp->base + ADSP2_LOCK_REGION_CTRL, |
| 3973 | 3996 | ADSP2_CTRL_ERR_EINT, ADSP2_CTRL_ERR_EINT); |
| 3974 | 3997 | |
| 3998 | +error: | |
| 3999 | + mutex_unlock(&dsp->pwr_lock); | |
| 4000 | + | |
| 3975 | 4001 | return IRQ_HANDLED; |
| 3976 | 4002 | } |
| 3977 | 4003 | EXPORT_SYMBOL_GPL(wm_adsp2_bus_error); |
| @@ -85,6 +85,7 @@ struct wm_adsp { · 84 unmodified lines | ||
| 85 | 85 | bool preloaded; |
| 86 | 86 | bool booted; |
| 87 | 87 | bool running; |
| 88 | + bool fatal_error; | |
| 88 | 89 | |
| 89 | 90 | struct list_head ctl_list; |
| 90 | 91 | |
| @@ -445,6 +445,19 @@ struct dma_chan *fsl_asrc_get_dma_channel(struct fsl_asrc_pair *pair, bool dir) · 444 unmodified lines | ||
| 445 | 445 | } |
| 446 | 446 | EXPORT_SYMBOL_GPL(fsl_asrc_get_dma_channel); |
| 447 | 447 | |
| 448 | +static int fsl_asrc_dai_startup(struct snd_pcm_substream *substream, | |
| 449 | + struct snd_soc_dai *dai) | |
| 450 | +{ | |
| 451 | + struct fsl_asrc *asrc_priv = snd_soc_dai_get_drvdata(dai); | |
| 452 | + | |
| 453 | + /* Odd channel number is not valid for older ASRC (channel_bits==3) */ | |
| 454 | + if (asrc_priv->channel_bits == 3) | |
| 455 | + snd_pcm_hw_constraint_step(substream->runtime, 0, | |
| 456 | + SNDRV_PCM_HW_PARAM_CHANNELS, 2); | |
| 457 | + | |
| 458 | + return 0; | |
| 459 | +} | |
| 460 | + | |
| 448 | 461 | static int fsl_asrc_dai_hw_params(struct snd_pcm_substream *substream, |
| 449 | 462 | struct snd_pcm_hw_params *params, |
| 450 | 463 | struct snd_soc_dai *dai) |
| @@ -539,6 +552,7 @@ static int fsl_asrc_dai_trigger(struct snd_pcm_substream *substream, int cmd, · 88 unmodified lines | ||
| 539 | 552 | } |
| 540 | 553 | |
| 541 | 554 | static const struct snd_soc_dai_ops fsl_asrc_dai_ops = { |
| 555 | + .startup = fsl_asrc_dai_startup, | |
| 542 | 556 | .hw_params = fsl_asrc_dai_hw_params, |
| 543 | 557 | .hw_free = fsl_asrc_dai_hw_free, |
| 544 | 558 | .trigger = fsl_asrc_dai_trigger, |
| @@ -54,6 +54,8 @@ struct fsl_esai { · 53 unmodified lines | ||
| 54 | 54 | u32 fifo_depth; |
| 55 | 55 | u32 slot_width; |
| 56 | 56 | u32 slots; |
| 57 | + u32 tx_mask; | |
| 58 | + u32 rx_mask; | |
| 57 | 59 | u32 hck_rate[2]; |
| 58 | 60 | u32 sck_rate[2]; |
| 59 | 61 | bool hck_dir[2]; |
| @@ -361,21 +363,13 @@ static int fsl_esai_set_dai_tdm_slot(struct snd_soc_dai *dai, u32 tx_mask, · 301 unmodified lines | ||
| 361 | 363 | regmap_update_bits(esai_priv->regmap, REG_ESAI_TCCR, |
| 362 | 364 | ESAI_xCCR_xDC_MASK, ESAI_xCCR_xDC(slots)); |
| 363 | 365 | |
| 364 | − regmap_update_bits(esai_priv->regmap, REG_ESAI_TSMA, | |
| 365 | − ESAI_xSMA_xS_MASK, ESAI_xSMA_xS(tx_mask)); | |
| 366 | − regmap_update_bits(esai_priv->regmap, REG_ESAI_TSMB, | |
| 367 | − ESAI_xSMB_xS_MASK, ESAI_xSMB_xS(tx_mask)); | |
| 368 | − | |
| 369 | 366 | regmap_update_bits(esai_priv->regmap, REG_ESAI_RCCR, |
| 370 | 367 | ESAI_xCCR_xDC_MASK, ESAI_xCCR_xDC(slots)); |
| 371 | 368 | |
| 372 | − regmap_update_bits(esai_priv->regmap, REG_ESAI_RSMA, | |
| 373 | − ESAI_xSMA_xS_MASK, ESAI_xSMA_xS(rx_mask)); | |
| 374 | − regmap_update_bits(esai_priv->regmap, REG_ESAI_RSMB, | |
| 375 | − ESAI_xSMB_xS_MASK, ESAI_xSMB_xS(rx_mask)); | |
| 376 | − | |
| 377 | 369 | esai_priv->slot_width = slot_width; |
| 378 | 370 | esai_priv->slots = slots; |
| 371 | + esai_priv->tx_mask = tx_mask; | |
| 372 | + esai_priv->rx_mask = rx_mask; | |
| 379 | 373 | |
| 380 | 374 | return 0; |
| 381 | 375 | } |
| @@ -596,6 +590,7 @@ static int fsl_esai_trigger(struct snd_pcm_substream *substream, int cmd, · 214 unmodified lines | ||
| 596 | 590 | bool tx = substream->stream == SNDRV_PCM_STREAM_PLAYBACK; |
| 597 | 591 | u8 i, channels = substream->runtime->channels; |
| 598 | 592 | u32 pins = DIV_ROUND_UP(channels, esai_priv->slots); |
| 593 | + u32 mask; | |
| 599 | 594 | |
| 600 | 595 | switch (cmd) { |
| 601 | 596 | case SNDRV_PCM_TRIGGER_START: |
| @@ -608,15 +603,38 @@ static int fsl_esai_trigger(struct snd_pcm_substream *substream, int cmd, · 6 unmodified lines | ||
| 608 | 603 | for (i = 0; tx && i < channels; i++) |
| 609 | 604 | regmap_write(esai_priv->regmap, REG_ESAI_ETDR, 0x0); |
| 610 | 605 | |
| 606 | + /* | |
| 607 | + * When set the TE/RE in the end of enablement flow, there | |
| 608 | + * will be channel swap issue for multi data line case. | |
| 609 | + * In order to workaround this issue, we switch the bit | |
| 610 | + * enablement sequence to below sequence | |
| 611 | + * 1) clear the xSMB & xSMA: which is done in probe and | |
| 612 | + * stop state. | |
| 613 | + * 2) set TE/RE | |
| 614 | + * 3) set xSMB | |
| 615 | + * 4) set xSMA: xSMA is the last one in this flow, which | |
| 616 | + * will trigger esai to start. | |
| 617 | + */ | |
| 611 | 618 | regmap_update_bits(esai_priv->regmap, REG_ESAI_xCR(tx), |
| 612 | 619 | tx ? ESAI_xCR_TE_MASK : ESAI_xCR_RE_MASK, |
| 613 | 620 | tx ? ESAI_xCR_TE(pins) : ESAI_xCR_RE(pins)); |
| 621 | + mask = tx ? esai_priv->tx_mask : esai_priv->rx_mask; | |
| 622 | + | |
| 623 | + regmap_update_bits(esai_priv->regmap, REG_ESAI_xSMB(tx), | |
| 624 | + ESAI_xSMB_xS_MASK, ESAI_xSMB_xS(mask)); | |
| 625 | + regmap_update_bits(esai_priv->regmap, REG_ESAI_xSMA(tx), | |
| 626 | + ESAI_xSMA_xS_MASK, ESAI_xSMA_xS(mask)); | |
| 627 | + | |
| 614 | 628 | break; |
| 615 | 629 | case SNDRV_PCM_TRIGGER_SUSPEND: |
| 616 | 630 | case SNDRV_PCM_TRIGGER_STOP: |
| 617 | 631 | case SNDRV_PCM_TRIGGER_PAUSE_PUSH: |
| 618 | 632 | regmap_update_bits(esai_priv->regmap, REG_ESAI_xCR(tx), |
| 619 | 633 | tx ? ESAI_xCR_TE_MASK : ESAI_xCR_RE_MASK, 0); |
| 634 | + regmap_update_bits(esai_priv->regmap, REG_ESAI_xSMA(tx), | |
| 635 | + ESAI_xSMA_xS_MASK, 0); | |
| 636 | + regmap_update_bits(esai_priv->regmap, REG_ESAI_xSMB(tx), | |
| 637 | + ESAI_xSMB_xS_MASK, 0); | |
| 620 | 638 | |
| 621 | 639 | /* Disable and reset FIFO */ |
| 622 | 640 | regmap_update_bits(esai_priv->regmap, REG_ESAI_xFCR(tx), |
| @@ -906,6 +924,15 @@ static int fsl_esai_probe(struct platform_device *pdev) · 283 unmodified lines | ||
| 906 | 924 | return ret; |
| 907 | 925 | } |
| 908 | 926 | |
| 927 | + esai_priv->tx_mask = 0xFFFFFFFF; | |
| 928 | + esai_priv->rx_mask = 0xFFFFFFFF; | |
| 929 | + | |
| 930 | + /* Clear the TSMA, TSMB, RSMA, RSMB */ | |
| 931 | + regmap_write(esai_priv->regmap, REG_ESAI_TSMA, 0); | |
| 932 | + regmap_write(esai_priv->regmap, REG_ESAI_TSMB, 0); | |
| 933 | + regmap_write(esai_priv->regmap, REG_ESAI_RSMA, 0); | |
| 934 | + regmap_write(esai_priv->regmap, REG_ESAI_RSMB, 0); | |
| 935 | + | |
| 909 | 936 | ret = devm_snd_soc_register_component(&pdev->dev, &fsl_esai_component, |
| 910 | 937 | &fsl_esai_dai, 1); |
| 911 | 938 | if (ret) { |
| @@ -20,6 +20,8 @@ · 19 unmodified lines | ||
| 20 | 20 | #include <linux/string.h> |
| 21 | 21 | #include <sound/simple_card_utils.h> |
| 22 | 22 | |
| 23 | +#define DPCM_SELECTABLE 1 | |
| 24 | + | |
| 23 | 25 | struct graph_priv { |
| 24 | 26 | struct snd_soc_card snd_card; |
| 25 | 27 | struct graph_dai_props { |
| @@ -440,6 +442,7 @@ static int graph_for_each_link(struct graph_priv *priv, · 414 unmodified lines | ||
| 440 | 442 | struct device_node *codec_port; |
| 441 | 443 | struct device_node *codec_port_old = NULL; |
| 442 | 444 | struct asoc_simple_card_data adata; |
| 445 | + uintptr_t dpcm_selectable = (uintptr_t)of_device_get_match_data(dev); | |
| 443 | 446 | int rc, ret; |
| 444 | 447 | |
| 445 | 448 | /* loop for all listed CPU port */ |
| @@ -470,8 +473,9 @@ static int graph_for_each_link(struct graph_priv *priv, · 24 unmodified lines | ||
| 470 | 473 | * if Codec port has many endpoints, |
| 471 | 474 | * or has convert-xxx property |
| 472 | 475 | */ |
| 473 | − if ((of_get_child_count(codec_port) > 1) || | |
| 474 | − adata.convert_rate || adata.convert_channels) | |
| 476 | + if (dpcm_selectable && | |
| 477 | + ((of_get_child_count(codec_port) > 1) || | |
| 478 | + adata.convert_rate || adata.convert_channels)) | |
| 475 | 479 | ret = func_dpcm(priv, cpu_ep, codec_ep, li, |
| 476 | 480 | (codec_port_old == codec_port)); |
| 477 | 481 | /* else normal sound */ |
| @@ -732,7 +736,8 @@ static int graph_remove(struct platform_device *pdev) · 254 unmodified lines | ||
| 732 | 736 | |
| 733 | 737 | static const struct of_device_id graph_of_match[] = { |
| 734 | 738 | { .compatible = "audio-graph-card", }, |
| 735 | − { .compatible = "audio-graph-scu-card", }, | |
| 739 | + { .compatible = "audio-graph-scu-card", | |
| 740 | + .data = (void *)DPCM_SELECTABLE }, | |
| 736 | 741 | {}, |
| 737 | 742 | }; |
| 738 | 743 | MODULE_DEVICE_TABLE(of, graph_of_match); |
| @@ -9,12 +9,15 @@ · 8 unmodified lines | ||
| 9 | 9 | #include <linux/device.h> |
| 10 | 10 | #include <linux/module.h> |
| 11 | 11 | #include <linux/of.h> |
| 12 | +#include <linux/of_device.h> | |
| 12 | 13 | #include <linux/platform_device.h> |
| 13 | 14 | #include <linux/string.h> |
| 14 | 15 | #include <sound/simple_card.h> |
| 15 | 16 | #include <sound/soc-dai.h> |
| 16 | 17 | #include <sound/soc.h> |
| 17 | 18 | |
| 19 | +#define DPCM_SELECTABLE 1 | |
| 20 | + | |
| 18 | 21 | struct simple_priv { |
| 19 | 22 | struct snd_soc_card snd_card; |
| 20 | 23 | struct simple_dai_props { |
| @@ -441,6 +444,7 @@ static int simple_for_each_link(struct simple_priv *priv, · 420 unmodified lines | ||
| 441 | 444 | struct device *dev = simple_priv_to_dev(priv); |
| 442 | 445 | struct device_node *top = dev->of_node; |
| 443 | 446 | struct device_node *node; |
| 447 | + uintptr_t dpcm_selectable = (uintptr_t)of_device_get_match_data(dev); | |
| 444 | 448 | bool is_top = 0; |
| 445 | 449 | int ret = 0; |
| 446 | 450 | |
| @@ -480,8 +484,9 @@ static int simple_for_each_link(struct simple_priv *priv, · 33 unmodified lines | ||
| 480 | 484 | * if it has many CPUs, |
| 481 | 485 | * or has convert-xxx property |
| 482 | 486 | */ |
| 483 | − if (num > 2 || | |
| 484 | − adata.convert_rate || adata.convert_channels) | |
| 487 | + if (dpcm_selectable && | |
| 488 | + (num > 2 || | |
| 489 | + adata.convert_rate || adata.convert_channels)) | |
| 485 | 490 | ret = func_dpcm(priv, np, codec, li, is_top); |
| 486 | 491 | /* else normal sound */ |
| 487 | 492 | else |
| @@ -822,7 +827,8 @@ static int simple_remove(struct platform_device *pdev) · 334 unmodified lines | ||
| 822 | 827 | |
| 823 | 828 | static const struct of_device_id simple_of_match[] = { |
| 824 | 829 | { .compatible = "simple-audio-card", }, |
| 825 | − { .compatible = "simple-scu-audio-card", }, | |
| 830 | + { .compatible = "simple-scu-audio-card", | |
| 831 | + .data = (void *)DPCM_SELECTABLE }, | |
| 826 | 832 | {}, |
| 827 | 833 | }; |
| 828 | 834 | MODULE_DEVICE_TABLE(of, simple_of_match); |
| @@ -706,9 +706,17 @@ static int sst_soc_probe(struct snd_soc_component *component) · 705 unmodified lines | ||
| 706 | 706 | return sst_dsp_init_v2_dpcm(component); |
| 707 | 707 | } |
| 708 | 708 | |
| 709 | +static void sst_soc_remove(struct snd_soc_component *component) | |
| 710 | +{ | |
| 711 | + struct sst_data *drv = dev_get_drvdata(component->dev); | |
| 712 | + | |
| 713 | + drv->soc_card = NULL; | |
| 714 | +} | |
| 715 | + | |
| 709 | 716 | static const struct snd_soc_component_driver sst_soc_platform_drv = { |
| 710 | 717 | .name = DRV_NAME, |
| 711 | 718 | .probe = sst_soc_probe, |
| 719 | + .remove = sst_soc_remove, | |
| 712 | 720 | .ops = &sst_platform_ops, |
| 713 | 721 | .compr_ops = &sst_platform_compr_ops, |
| 714 | 722 | .pcm_new = sst_pcm_new, |
| @@ -43,6 +43,7 @@ struct cht_mc_private { · 42 unmodified lines | ||
| 43 | 43 | struct clk *mclk; |
| 44 | 44 | struct snd_soc_jack jack; |
| 45 | 45 | bool ts3a227e_present; |
| 46 | + int quirks; | |
| 46 | 47 | }; |
| 47 | 48 | |
| 48 | 49 | static int platform_clock_control(struct snd_soc_dapm_widget *w, |
| @@ -54,6 +55,10 @@ static int platform_clock_control(struct snd_soc_dapm_widget *w, · 5 unmodified lines | ||
| 54 | 55 | struct cht_mc_private *ctx = snd_soc_card_get_drvdata(card); |
| 55 | 56 | int ret; |
| 56 | 57 | |
| 58 | + /* See the comment in snd_cht_mc_probe() */ | |
| 59 | + if (ctx->quirks & QUIRK_PMC_PLT_CLK_0) | |
| 60 | + return 0; | |
| 61 | + | |
| 57 | 62 | codec_dai = snd_soc_card_get_codec_dai(card, CHT_CODEC_DAI); |
| 58 | 63 | if (!codec_dai) { |
| 59 | 64 | dev_err(card->dev, "Codec dai not found; Unable to set platform clock\n"); |
| @@ -223,6 +228,10 @@ static int cht_codec_init(struct snd_soc_pcm_runtime *runtime) · 163 unmodified lines | ||
| 223 | 228 | "jack detection gpios not added, error %d\n", ret); |
| 224 | 229 | } |
| 225 | 230 | |
| 231 | + /* See the comment in snd_cht_mc_probe() */ | |
| 232 | + if (ctx->quirks & QUIRK_PMC_PLT_CLK_0) | |
| 233 | + return 0; | |
| 234 | + | |
| 226 | 235 | /* |
| 227 | 236 | * The firmware might enable the clock at |
| 228 | 237 | * boot (this information may or may not |
| @@ -423,16 +432,15 @@ static int snd_cht_mc_probe(struct platform_device *pdev) · 194 unmodified lines | ||
| 423 | 432 | const char *mclk_name; |
| 424 | 433 | struct snd_soc_acpi_mach *mach; |
| 425 | 434 | const char *platform_name; |
| 426 | − int quirks = 0; | |
| 427 | − | |
| 428 | − dmi_id = dmi_first_match(cht_max98090_quirk_table); | |
| 429 | − if (dmi_id) | |
| 430 | − quirks = (unsigned long)dmi_id->driver_data; | |
| 431 | 435 | |
| 432 | 436 | drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); |
| 433 | 437 | if (!drv) |
| 434 | 438 | return -ENOMEM; |
| 435 | 439 | |
| 440 | + dmi_id = dmi_first_match(cht_max98090_quirk_table); | |
| 441 | + if (dmi_id) | |
| 442 | + drv->quirks = (unsigned long)dmi_id->driver_data; | |
| 443 | + | |
| 436 | 444 | drv->ts3a227e_present = acpi_dev_found("104C227E"); |
| 437 | 445 | if (!drv->ts3a227e_present) { |
| 438 | 446 | /* no need probe TI jack detection chip */ |
| @@ -458,7 +466,7 @@ static int snd_cht_mc_probe(struct platform_device *pdev) · 19 unmodified lines | ||
| 458 | 466 | snd_soc_card_cht.dev = &pdev->dev; |
| 459 | 467 | snd_soc_card_set_drvdata(&snd_soc_card_cht, drv); |
| 460 | 468 | |
| 461 | − if (quirks & QUIRK_PMC_PLT_CLK_0) | |
| 469 | + if (drv->quirks & QUIRK_PMC_PLT_CLK_0) | |
| 462 | 470 | mclk_name = "pmc_plt_clk_0"; |
| 463 | 471 | else |
| 464 | 472 | mclk_name = "pmc_plt_clk_3"; |
| @@ -471,6 +479,21 @@ static int snd_cht_mc_probe(struct platform_device *pdev) · 6 unmodified lines | ||
| 471 | 479 | return PTR_ERR(drv->mclk); |
| 472 | 480 | } |
| 473 | 481 | |
| 482 | + /* | |
| 483 | + * Boards which have the MAX98090's clk connected to clk_0 do not seem | |
| 484 | + * to like it if we muck with the clock. If we disable the clock when | |
| 485 | + * it is unused we get "max98090 i2c-193C9890:00: PLL unlocked" errors | |
| 486 | + * and the PLL never seems to lock again. | |
| 487 | + * So for these boards we enable it here once and leave it at that. | |
| 488 | + */ | |
| 489 | + if (drv->quirks & QUIRK_PMC_PLT_CLK_0) { | |
| 490 | + ret_val = clk_prepare_enable(drv->mclk); | |
| 491 | + if (ret_val < 0) { | |
| 492 | + dev_err(&pdev->dev, "MCLK enable error: %d\n", ret_val); | |
| 493 | + return ret_val; | |
| 494 | + } | |
| 495 | + } | |
| 496 | + | |
| 474 | 497 | ret_val = devm_snd_soc_register_card(&pdev->dev, &snd_soc_card_cht); |
| 475 | 498 | if (ret_val) { |
| 476 | 499 | dev_err(&pdev->dev, |
| @@ -481,11 +504,23 @@ static int snd_cht_mc_probe(struct platform_device *pdev) · 4 unmodified lines | ||
| 481 | 504 | return ret_val; |
| 482 | 505 | } |
| 483 | 506 | |
| 507 | +static int snd_cht_mc_remove(struct platform_device *pdev) | |
| 508 | +{ | |
| 509 | + struct snd_soc_card *card = platform_get_drvdata(pdev); | |
| 510 | + struct cht_mc_private *ctx = snd_soc_card_get_drvdata(card); | |
| 511 | + | |
| 512 | + if (ctx->quirks & QUIRK_PMC_PLT_CLK_0) | |
| 513 | + clk_disable_unprepare(ctx->mclk); | |
| 514 | + | |
| 515 | + return 0; | |
| 516 | +} | |
| 517 | + | |
| 484 | 518 | static struct platform_driver snd_cht_mc_driver = { |
| 485 | 519 | .driver = { |
| 486 | 520 | .name = "cht-bsw-max98090", |
| 487 | 521 | }, |
| 488 | 522 | .probe = snd_cht_mc_probe, |
| 523 | + .remove = snd_cht_mc_remove, | |
| 489 | 524 | }; |
| 490 | 525 | |
| 491 | 526 | module_platform_driver(snd_cht_mc_driver) |
| @@ -405,7 +405,7 @@ static const struct snd_pcm_hw_constraint_list constraints_dmic_channels = { · 404 unmodified lines | ||
| 405 | 405 | }; |
| 406 | 406 | |
| 407 | 407 | static const unsigned int dmic_2ch[] = { |
| 408 | − 4, | |
| 408 | + 2, | |
| 409 | 409 | }; |
| 410 | 410 | |
| 411 | 411 | static const struct snd_pcm_hw_constraint_list constraints_dmic_2ch = { |
| @@ -483,6 +483,7 @@ static void skl_set_base_module_format(struct skl_sst *ctx, · 482 unmodified lines | ||
| 483 | 483 | base_cfg->audio_fmt.bit_depth = format->bit_depth; |
| 484 | 484 | base_cfg->audio_fmt.valid_bit_depth = format->valid_bit_depth; |
| 485 | 485 | base_cfg->audio_fmt.ch_cfg = format->ch_cfg; |
| 486 | + base_cfg->audio_fmt.sample_type = format->sample_type; | |
| 486 | 487 | |
| 487 | 488 | dev_dbg(ctx->dev, "bit_depth=%x valid_bd=%x ch_config=%x\n", |
| 488 | 489 | format->bit_depth, format->valid_bit_depth, |
| @@ -181,6 +181,7 @@ int skl_pcm_link_dma_prepare(struct device *dev, struct skl_pipe_params *params) · 180 unmodified lines | ||
| 181 | 181 | struct hdac_stream *hstream; |
| 182 | 182 | struct hdac_ext_stream *stream; |
| 183 | 183 | struct hdac_ext_link *link; |
| 184 | + unsigned char stream_tag; | |
| 184 | 185 | |
| 185 | 186 | hstream = snd_hdac_get_stream(bus, params->stream, |
| 186 | 187 | params->link_dma_id + 1); |
| @@ -199,10 +200,13 @@ int skl_pcm_link_dma_prepare(struct device *dev, struct skl_pipe_params *params) · 12 unmodified lines | ||
| 199 | 200 | |
| 200 | 201 | snd_hdac_ext_link_stream_setup(stream, format_val); |
| 201 | 202 | |
| 202 | − list_for_each_entry(link, &bus->hlink_list, list) { | |
| 203 | − if (link->index == params->link_index) | |
| 204 | − snd_hdac_ext_link_set_stream_id(link, | |
| 205 | − hstream->stream_tag); | |
| 203 | + stream_tag = hstream->stream_tag; | |
| 204 | + if (stream->hstream.direction == SNDRV_PCM_STREAM_PLAYBACK) { | |
| 205 | + list_for_each_entry(link, &bus->hlink_list, list) { | |
| 206 | + if (link->index == params->link_index) | |
| 207 | + snd_hdac_ext_link_set_stream_id(link, | |
| 208 | + stream_tag); | |
| 209 | + } | |
| 206 | 210 | } |
| 207 | 211 | |
| 208 | 212 | stream->link_prepared = 1; |
| @@ -645,6 +649,7 @@ static int skl_link_hw_free(struct snd_pcm_substream *substream, · 436 unmodified lines | ||
| 645 | 649 | struct hdac_ext_stream *link_dev = |
| 646 | 650 | snd_soc_dai_get_dma_data(dai, substream); |
| 647 | 651 | struct hdac_ext_link *link; |
| 652 | + unsigned char stream_tag; | |
| 648 | 653 | |
| 649 | 654 | dev_dbg(dai->dev, "%s: %s\n", __func__, dai->name); |
| 650 | 655 | |
| @@ -654,7 +659,11 @@ static int skl_link_hw_free(struct snd_pcm_substream *substream, · 3 unmodified lines | ||
| 654 | 659 | if (!link) |
| 655 | 660 | return -EINVAL; |
| 656 | 661 | |
| 657 | − snd_hdac_ext_link_clear_stream_id(link, hdac_stream(link_dev)->stream_tag); | |
| 662 | + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { | |
| 663 | + stream_tag = hdac_stream(link_dev)->stream_tag; | |
| 664 | + snd_hdac_ext_link_clear_stream_id(link, stream_tag); | |
| 665 | + } | |
| 666 | + | |
| 658 | 667 | snd_hdac_ext_stream_release(link_dev, HDAC_EXT_STREAM_TYPE_LINK); |
| 659 | 668 | return 0; |
| 660 | 669 | } |
| @@ -1453,13 +1462,20 @@ static int skl_platform_soc_probe(struct snd_soc_component *component) · 792 unmodified lines | ||
| 1453 | 1462 | return 0; |
| 1454 | 1463 | } |
| 1455 | 1464 | |
| 1465 | +static void skl_pcm_remove(struct snd_soc_component *component) | |
| 1466 | +{ | |
| 1467 | + /* remove topology */ | |
| 1468 | + snd_soc_tplg_component_remove(component, SND_SOC_TPLG_INDEX_ALL); | |
| 1469 | +} | |
| 1470 | + | |
| 1456 | 1471 | static const struct snd_soc_component_driver skl_component = { |
| 1457 | 1472 | .name = "pcm", |
| 1458 | 1473 | .probe = skl_platform_soc_probe, |
| 1474 | + .remove = skl_pcm_remove, | |
| 1459 | 1475 | .ops = &skl_platform_ops, |
| 1460 | 1476 | .pcm_new = skl_pcm_new, |
| 1461 | 1477 | .pcm_free = skl_pcm_free, |
| 1462 | − .ignore_module_refcount = 1, /* do not increase the refcount in core */ | |
| 1478 | + .module_get_upon_open = 1, /* increment refcount when a pcm is opened */ | |
| 1463 | 1479 | }; |
| 1464 | 1480 | |
| 1465 | 1481 | int skl_platform_register(struct device *dev) |
| @@ -49,6 +49,7 @@ enum bt_sco_state { · 48 unmodified lines | ||
| 49 | 49 | BT_SCO_STATE_IDLE, |
| 50 | 50 | BT_SCO_STATE_RUNNING, |
| 51 | 51 | BT_SCO_STATE_ENDING, |
| 52 | + BT_SCO_STATE_LOOPBACK, | |
| 52 | 53 | }; |
| 53 | 54 | |
| 54 | 55 | enum bt_sco_direct { |
| @@ -486,7 +487,8 @@ static irqreturn_t mtk_btcvsd_snd_irq_handler(int irq_id, void *dev) · 431 unmodified lines | ||
| 486 | 487 | if (bt->rx->state != BT_SCO_STATE_RUNNING && |
| 487 | 488 | bt->rx->state != BT_SCO_STATE_ENDING && |
| 488 | 489 | bt->tx->state != BT_SCO_STATE_RUNNING && |
| 489 | − bt->tx->state != BT_SCO_STATE_ENDING) { | |
| 490 | + bt->tx->state != BT_SCO_STATE_ENDING && | |
| 491 | + bt->tx->state != BT_SCO_STATE_LOOPBACK) { | |
| 490 | 492 | dev_warn(bt->dev, "%s(), in idle state: rx->state: %d, tx->state: %d\n", |
| 491 | 493 | __func__, bt->rx->state, bt->tx->state); |
| 492 | 494 | goto irq_handler_exit; |
| @@ -512,6 +514,42 @@ static irqreturn_t mtk_btcvsd_snd_irq_handler(int irq_id, void *dev) · 19 unmodified lines | ||
| 512 | 514 | buf_cnt_tx = btsco_packet_info[packet_type][2]; |
| 513 | 515 | buf_cnt_rx = btsco_packet_info[packet_type][3]; |
| 514 | 516 | |
| 517 | + if (bt->tx->state == BT_SCO_STATE_LOOPBACK) { | |
| 518 | + u8 *src, *dst; | |
| 519 | + unsigned long connsys_addr_rx, ap_addr_rx; | |
| 520 | + unsigned long connsys_addr_tx, ap_addr_tx; | |
| 521 | + | |
| 522 | + connsys_addr_rx = *bt->bt_reg_pkt_r; | |
| 523 | + ap_addr_rx = (unsigned long)bt->bt_sram_bank2_base + | |
| 524 | + (connsys_addr_rx & 0xFFFF); | |
| 525 | + | |
| 526 | + connsys_addr_tx = *bt->bt_reg_pkt_w; | |
| 527 | + ap_addr_tx = (unsigned long)bt->bt_sram_bank2_base + | |
| 528 | + (connsys_addr_tx & 0xFFFF); | |
| 529 | + | |
| 530 | + if (connsys_addr_tx == 0xdeadfeed || | |
| 531 | + connsys_addr_rx == 0xdeadfeed) { | |
| 532 | + /* bt return 0xdeadfeed if read reg during bt sleep */ | |
| 533 | + dev_warn(bt->dev, "%s(), connsys_addr_tx == 0xdeadfeed\n", | |
| 534 | + __func__); | |
| 535 | + goto irq_handler_exit; | |
| 536 | + } | |
| 537 | + | |
| 538 | + src = (u8 *)ap_addr_rx; | |
| 539 | + dst = (u8 *)ap_addr_tx; | |
| 540 | + | |
| 541 | + mtk_btcvsd_snd_data_transfer(BT_SCO_DIRECT_BT2ARM, src, | |
| 542 | + bt->tx->temp_packet_buf, | |
| 543 | + packet_length, | |
| 544 | + packet_num); | |
| 545 | + mtk_btcvsd_snd_data_transfer(BT_SCO_DIRECT_ARM2BT, | |
| 546 | + bt->tx->temp_packet_buf, dst, | |
| 547 | + packet_length, | |
| 548 | + packet_num); | |
| 549 | + bt->rx->rw_cnt++; | |
| 550 | + bt->tx->rw_cnt++; | |
| 551 | + } | |
| 552 | + | |
| 515 | 553 | if (bt->rx->state == BT_SCO_STATE_RUNNING || |
| 516 | 554 | bt->rx->state == BT_SCO_STATE_ENDING) { |
| 517 | 555 | if (bt->rx->xrun) { |
| @@ -1067,6 +1105,33 @@ static int btcvsd_band_set(struct snd_kcontrol *kcontrol, · 549 unmodified lines | ||
| 1067 | 1105 | return 0; |
| 1068 | 1106 | } |
| 1069 | 1107 | |
| 1108 | +static int btcvsd_loopback_get(struct snd_kcontrol *kcontrol, | |
| 1109 | + struct snd_ctl_elem_value *ucontrol) | |
| 1110 | +{ | |
| 1111 | + struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol); | |
| 1112 | + struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt); | |
| 1113 | + bool lpbk_en = bt->tx->state == BT_SCO_STATE_LOOPBACK; | |
| 1114 | + | |
| 1115 | + ucontrol->value.integer.value[0] = lpbk_en; | |
| 1116 | + return 0; | |
| 1117 | +} | |
| 1118 | + | |
| 1119 | +static int btcvsd_loopback_set(struct snd_kcontrol *kcontrol, | |
| 1120 | + struct snd_ctl_elem_value *ucontrol) | |
| 1121 | +{ | |
| 1122 | + struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol); | |
| 1123 | + struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt); | |
| 1124 | + | |
| 1125 | + if (ucontrol->value.integer.value[0]) { | |
| 1126 | + mtk_btcvsd_snd_set_state(bt, bt->tx, BT_SCO_STATE_LOOPBACK); | |
| 1127 | + mtk_btcvsd_snd_set_state(bt, bt->rx, BT_SCO_STATE_LOOPBACK); | |
| 1128 | + } else { | |
| 1129 | + mtk_btcvsd_snd_set_state(bt, bt->tx, BT_SCO_STATE_RUNNING); | |
| 1130 | + mtk_btcvsd_snd_set_state(bt, bt->rx, BT_SCO_STATE_RUNNING); | |
| 1131 | + } | |
| 1132 | + return 0; | |
| 1133 | +} | |
| 1134 | + | |
| 1070 | 1135 | static int btcvsd_tx_mute_get(struct snd_kcontrol *kcontrol, |
| 1071 | 1136 | struct snd_ctl_elem_value *ucontrol) |
| 1072 | 1137 | { |
| @@ -1202,6 +1267,8 @@ static int btcvsd_tx_timestamp_get(struct snd_kcontrol *kcontrol, · 129 unmodified lines | ||
| 1202 | 1267 | static const struct snd_kcontrol_new mtk_btcvsd_snd_controls[] = { |
| 1203 | 1268 | SOC_ENUM_EXT("BTCVSD Band", btcvsd_enum[0], |
| 1204 | 1269 | btcvsd_band_get, btcvsd_band_set), |
| 1270 | + SOC_SINGLE_BOOL_EXT("BTCVSD Loopback Switch", 0, | |
| 1271 | + btcvsd_loopback_get, btcvsd_loopback_set), | |
| 1205 | 1272 | SOC_SINGLE_BOOL_EXT("BTCVSD Tx Mute Switch", 0, |
| 1206 | 1273 | btcvsd_tx_mute_get, btcvsd_tx_mute_set), |
| 1207 | 1274 | SOC_SINGLE_BOOL_EXT("BTCVSD Tx Irq Received Switch", 0, |
| @@ -605,6 +605,10 @@ void mt8183_mck_disable(struct mtk_base_afe *afe, int mck_id) · 604 unmodified lines | ||
| 605 | 605 | int m_sel_id = mck_div[mck_id].m_sel_id; |
| 606 | 606 | int div_clk_id = mck_div[mck_id].div_clk_id; |
| 607 | 607 | |
| 608 | + /* i2s5 mck not support */ | |
| 609 | + if (mck_id == MT8183_I2S5_MCK) | |
| 610 | + return; | |
| 611 | + | |
| 608 | 612 | clk_disable_unprepare(afe_priv->clk[div_clk_id]); |
| 609 | 613 | if (m_sel_id >= 0) |
| 610 | 614 | clk_disable_unprepare(afe_priv->clk[m_sel_id]); |
| @@ -24,7 +24,7 @@ · 23 unmodified lines | ||
| 24 | 24 | |
| 25 | 25 | #include "rockchip_pdm.h" |
| 26 | 26 | |
| 27 | −#define PDM_DMA_BURST_SIZE (16) /* size * width: 16*4 = 64 bytes */ | |
| 27 | +#define PDM_DMA_BURST_SIZE (8) /* size * width: 8*4 = 32 bytes */ | |
| 28 | 28 | |
| 29 | 29 | struct rk_pdm_dev { |
| 30 | 30 | struct device *dev; |
| @@ -208,7 +208,9 @@ static int rockchip_pdm_set_fmt(struct snd_soc_dai *cpu_dai, · 177 unmodified lines | ||
| 208 | 208 | return -EINVAL; |
| 209 | 209 | } |
| 210 | 210 | |
| 211 | + pm_runtime_get_sync(cpu_dai->dev); | |
| 211 | 212 | regmap_update_bits(pdm->regmap, PDM_CLK_CTRL, mask, val); |
| 213 | + pm_runtime_put(cpu_dai->dev); | |
| 212 | 214 | |
| 213 | 215 | return 0; |
| 214 | 216 | } |
| @@ -1130,11 +1130,11 @@ static const struct snd_soc_dapm_widget samsung_i2s_widgets[] = { · 1129 unmodified lines | ||
| 1130 | 1130 | }; |
| 1131 | 1131 | |
| 1132 | 1132 | static const struct snd_soc_dapm_route samsung_i2s_dapm_routes[] = { |
| 1133 | − { "Playback Mixer", NULL, "Primary" }, | |
| 1134 | − { "Playback Mixer", NULL, "Secondary" }, | |
| 1133 | + { "Playback Mixer", NULL, "Primary Playback" }, | |
| 1134 | + { "Playback Mixer", NULL, "Secondary Playback" }, | |
| 1135 | 1135 | |
| 1136 | 1136 | { "Mixer DAI TX", NULL, "Playback Mixer" }, |
| 1137 | − { "Playback Mixer", NULL, "Mixer DAI RX" }, | |
| 1137 | + { "Primary Capture", NULL, "Mixer DAI RX" }, | |
| 1138 | 1138 | }; |
| 1139 | 1139 | |
| 1140 | 1140 | static const struct snd_soc_component_driver samsung_i2s_component = { |
| @@ -1155,7 +1155,8 @@ static int i2s_alloc_dais(struct samsung_i2s_priv *priv, · 14 unmodified lines | ||
| 1155 | 1155 | int num_dais) |
| 1156 | 1156 | { |
| 1157 | 1157 | static const char *dai_names[] = { "samsung-i2s", "samsung-i2s-sec" }; |
| 1158 | − static const char *stream_names[] = { "Primary", "Secondary" }; | |
| 1158 | + static const char *stream_names[] = { "Primary Playback", | |
| 1159 | + "Secondary Playback" }; | |
| 1159 | 1160 | struct snd_soc_dai_driver *dai_drv; |
| 1160 | 1161 | struct i2s_dai *dai; |
| 1161 | 1162 | int i; |
| @@ -1201,6 +1202,7 @@ static int i2s_alloc_dais(struct samsung_i2s_priv *priv, · 39 unmodified lines | ||
| 1201 | 1202 | dai_drv->capture.channels_max = 2; |
| 1202 | 1203 | dai_drv->capture.rates = i2s_dai_data->pcm_rates; |
| 1203 | 1204 | dai_drv->capture.formats = SAMSUNG_I2S_FMTS; |
| 1205 | + dai_drv->capture.stream_name = "Primary Capture"; | |
| 1204 | 1206 | |
| 1205 | 1207 | return 0; |
| 1206 | 1208 | } |
| @@ -91,11 +91,11 @@ static int odroid_card_be_hw_params(struct snd_pcm_substream *substream, · 90 unmodified lines | ||
| 91 | 91 | return ret; |
| 92 | 92 | |
| 93 | 93 | /* |
| 94 | − * We add 1 to the rclk_freq value in order to avoid too low clock | |
| 94 | + * We add 2 to the rclk_freq value in order to avoid too low clock | |
| 95 | 95 | * frequency values due to the EPLL output frequency not being exact |
| 96 | 96 | * multiple of the audio sampling rate. |
| 97 | 97 | */ |
| 98 | − rclk_freq = params_rate(params) * rfs + 1; | |
| 98 | + rclk_freq = params_rate(params) * rfs + 2; | |
| 99 | 99 | |
| 100 | 100 | ret = clk_set_rate(priv->sclk_i2s, rclk_freq); |
| 101 | 101 | if (ret < 0) |
| @@ -110,6 +110,8 @@ static const struct of_device_id rsnd_of_match[] = { · 109 unmodified lines | ||
| 110 | 110 | { .compatible = "renesas,rcar_sound-gen1", .data = (void *)RSND_GEN1 }, |
| 111 | 111 | { .compatible = "renesas,rcar_sound-gen2", .data = (void *)RSND_GEN2 }, |
| 112 | 112 | { .compatible = "renesas,rcar_sound-gen3", .data = (void *)RSND_GEN3 }, |
| 113 | + /* Special Handling */ | |
| 114 | + { .compatible = "renesas,rcar_sound-r8a77990", .data = (void *)(RSND_GEN3 | RSND_SOC_E) }, | |
| 113 | 115 | {}, |
| 114 | 116 | }; |
| 115 | 117 | MODULE_DEVICE_TABLE(of, rsnd_of_match); |
| @@ -607,6 +607,8 @@ struct rsnd_priv { · 606 unmodified lines | ||
| 607 | 607 | #define RSND_GEN1 (1 << 0) |
| 608 | 608 | #define RSND_GEN2 (2 << 0) |
| 609 | 609 | #define RSND_GEN3 (3 << 0) |
| 610 | +#define RSND_SOC_MASK (0xFF << 4) | |
| 611 | +#define RSND_SOC_E (1 << 4) /* E1/E2/E3 */ | |
| 610 | 612 | |
| 611 | 613 | /* |
| 612 | 614 | * below value will be filled on rsnd_gen_probe() |
| @@ -679,6 +681,9 @@ struct rsnd_priv { · 66 unmodified lines | ||
| 679 | 681 | #define rsnd_is_gen1(priv) (((priv)->flags & RSND_GEN_MASK) == RSND_GEN1) |
| 680 | 682 | #define rsnd_is_gen2(priv) (((priv)->flags & RSND_GEN_MASK) == RSND_GEN2) |
| 681 | 683 | #define rsnd_is_gen3(priv) (((priv)->flags & RSND_GEN_MASK) == RSND_GEN3) |
| 684 | +#define rsnd_is_e3(priv) (((priv)->flags & \ | |
| 685 | + (RSND_GEN_MASK | RSND_SOC_MASK)) == \ | |
| 686 | + (RSND_GEN3 | RSND_SOC_E)) | |
| 682 | 687 | |
| 683 | 688 | #define rsnd_flags_has(p, f) ((p)->flags & (f)) |
| 684 | 689 | #define rsnd_flags_set(p, f) ((p)->flags |= (f)) |
| @@ -14,7 +14,6 @@ · 13 unmodified lines | ||
| 14 | 14 | */ |
| 15 | 15 | |
| 16 | 16 | #include "rsnd.h" |
| 17 | −#include <linux/sys_soc.h> | |
| 18 | 17 | |
| 19 | 18 | #define SRC_NAME "src" |
| 20 | 19 | |
| @@ -135,7 +134,7 @@ unsigned int rsnd_src_get_rate(struct rsnd_priv *priv, · 114 unmodified lines | ||
| 135 | 134 | return rate; |
| 136 | 135 | } |
| 137 | 136 | |
| 138 | −const static u32 bsdsr_table_pattern1[] = { | |
| 137 | +static const u32 bsdsr_table_pattern1[] = { | |
| 139 | 138 | 0x01800000, /* 6 - 1/6 */ |
| 140 | 139 | 0x01000000, /* 6 - 1/4 */ |
| 141 | 140 | 0x00c00000, /* 6 - 1/3 */ |
| @@ -144,7 +143,7 @@ const static u32 bsdsr_table_pattern1[] = { · 2 unmodified lines | ||
| 144 | 143 | 0x00400000, /* 6 - 1 */ |
| 145 | 144 | }; |
| 146 | 145 | |
| 147 | −const static u32 bsdsr_table_pattern2[] = { | |
| 146 | +static const u32 bsdsr_table_pattern2[] = { | |
| 148 | 147 | 0x02400000, /* 6 - 1/6 */ |
| 149 | 148 | 0x01800000, /* 6 - 1/4 */ |
| 150 | 149 | 0x01200000, /* 6 - 1/3 */ |
| @@ -153,7 +152,7 @@ const static u32 bsdsr_table_pattern2[] = { · 2 unmodified lines | ||
| 153 | 152 | 0x00600000, /* 6 - 1 */ |
| 154 | 153 | }; |
| 155 | 154 | |
| 156 | −const static u32 bsisr_table[] = { | |
| 155 | +static const u32 bsisr_table[] = { | |
| 157 | 156 | 0x00100060, /* 6 - 1/6 */ |
| 158 | 157 | 0x00100040, /* 6 - 1/4 */ |
| 159 | 158 | 0x00100030, /* 6 - 1/3 */ |
| @@ -162,7 +161,7 @@ const static u32 bsisr_table[] = { · 2 unmodified lines | ||
| 162 | 161 | 0x00100020, /* 6 - 1 */ |
| 163 | 162 | }; |
| 164 | 163 | |
| 165 | −const static u32 chan288888[] = { | |
| 164 | +static const u32 chan288888[] = { | |
| 166 | 165 | 0x00000006, /* 1 to 2 */ |
| 167 | 166 | 0x000001fe, /* 1 to 8 */ |
| 168 | 167 | 0x000001fe, /* 1 to 8 */ |
| @@ -171,7 +170,7 @@ const static u32 chan288888[] = { · 2 unmodified lines | ||
| 171 | 170 | 0x000001fe, /* 1 to 8 */ |
| 172 | 171 | }; |
| 173 | 172 | |
| 174 | −const static u32 chan244888[] = { | |
| 173 | +static const u32 chan244888[] = { | |
| 175 | 174 | 0x00000006, /* 1 to 2 */ |
| 176 | 175 | 0x0000001e, /* 1 to 4 */ |
| 177 | 176 | 0x0000001e, /* 1 to 4 */ |
| @@ -180,7 +179,7 @@ const static u32 chan244888[] = { · 2 unmodified lines | ||
| 180 | 179 | 0x000001fe, /* 1 to 8 */ |
| 181 | 180 | }; |
| 182 | 181 | |
| 183 | −const static u32 chan222222[] = { | |
| 182 | +static const u32 chan222222[] = { | |
| 184 | 183 | 0x00000006, /* 1 to 2 */ |
| 185 | 184 | 0x00000006, /* 1 to 2 */ |
| 186 | 185 | 0x00000006, /* 1 to 2 */ |
| @@ -189,18 +188,12 @@ const static u32 chan222222[] = { · 2 unmodified lines | ||
| 189 | 188 | 0x00000006, /* 1 to 2 */ |
| 190 | 189 | }; |
| 191 | 190 | |
| 192 | −static const struct soc_device_attribute ov_soc[] = { | |
| 193 | − { .soc_id = "r8a77990" }, /* E3 */ | |
| 194 | − { /* sentinel */ } | |
| 195 | −}; | |
| 196 | − | |
| 197 | 191 | static void rsnd_src_set_convert_rate(struct rsnd_dai_stream *io, |
| 198 | 192 | struct rsnd_mod *mod) |
| 199 | 193 | { |
| 200 | 194 | struct rsnd_priv *priv = rsnd_mod_to_priv(mod); |
| 201 | 195 | struct device *dev = rsnd_priv_to_dev(priv); |
| 202 | 196 | struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); |
| 203 | − const struct soc_device_attribute *soc = soc_device_match(ov_soc); | |
| 204 | 197 | int is_play = rsnd_io_is_play(io); |
| 205 | 198 | int use_src = 0; |
| 206 | 199 | u32 fin, fout; |
| @@ -307,7 +300,7 @@ static void rsnd_src_set_convert_rate(struct rsnd_dai_stream *io, · 100 unmodified lines | ||
| 307 | 300 | /* |
| 308 | 301 | * E3 need to overwrite |
| 309 | 302 | */ |
| 310 | − if (soc) | |
| 303 | + if (rsnd_is_e3(priv)) | |
| 311 | 304 | switch (rsnd_mod_id(mod)) { |
| 312 | 305 | case 0: |
| 313 | 306 | case 4: |
| @@ -947,7 +947,7 @@ static void soc_cleanup_component(struct snd_soc_component *component) · 946 unmodified lines | ||
| 947 | 947 | snd_soc_dapm_free(snd_soc_component_get_dapm(component)); |
| 948 | 948 | soc_cleanup_component_debugfs(component); |
| 949 | 949 | component->card = NULL; |
| 950 | − if (!component->driver->ignore_module_refcount) | |
| 950 | + if (!component->driver->module_get_upon_open) | |
| 951 | 951 | module_put(component->dev->driver->owner); |
| 952 | 952 | } |
| 953 | 953 | |
| @@ -1381,7 +1381,7 @@ static int soc_probe_component(struct snd_soc_card *card, · 427 unmodified lines | ||
| 1381 | 1381 | return 0; |
| 1382 | 1382 | } |
| 1383 | 1383 | |
| 1384 | − if (!component->driver->ignore_module_refcount && | |
| 1384 | + if (!component->driver->module_get_upon_open && | |
| 1385 | 1385 | !try_module_get(component->dev->driver->owner)) |
| 1386 | 1386 | return -ENODEV; |
| 1387 | 1387 | |
| @@ -2797,6 +2797,7 @@ int snd_soc_register_card(struct snd_soc_card *card) · 1409 unmodified lines | ||
| 2797 | 2797 | |
| 2798 | 2798 | ret = soc_init_dai_link(card, link); |
| 2799 | 2799 | if (ret) { |
| 2800 | + soc_cleanup_platform(card); | |
| 2800 | 2801 | dev_err(card->dev, "ASoC: failed to init link %s\n", |
| 2801 | 2802 | link->name); |
| 2802 | 2803 | mutex_unlock(&client_mutex); |
| @@ -2819,6 +2820,7 @@ int snd_soc_register_card(struct snd_soc_card *card) · 16 unmodified lines | ||
| 2819 | 2820 | card->instantiated = 0; |
| 2820 | 2821 | mutex_init(&card->mutex); |
| 2821 | 2822 | mutex_init(&card->dapm_mutex); |
| 2823 | + spin_lock_init(&card->dpcm_lock); | |
| 2822 | 2824 | |
| 2823 | 2825 | return snd_soc_bind_card(card); |
| 2824 | 2826 | } |
| @@ -3650,6 +3650,13 @@ snd_soc_dapm_new_control_unlocked(struct snd_soc_dapm_context *dapm, · 3649 unmodified lines | ||
| 3650 | 3650 | case snd_soc_dapm_dac: |
| 3651 | 3651 | case snd_soc_dapm_aif_in: |
| 3652 | 3652 | case snd_soc_dapm_pga: |
| 3653 | + case snd_soc_dapm_buffer: | |
| 3654 | + case snd_soc_dapm_scheduler: | |
| 3655 | + case snd_soc_dapm_effect: | |
| 3656 | + case snd_soc_dapm_src: | |
| 3657 | + case snd_soc_dapm_asrc: | |
| 3658 | + case snd_soc_dapm_encoder: | |
| 3659 | + case snd_soc_dapm_decoder: | |
| 3653 | 3660 | case snd_soc_dapm_out_drv: |
| 3654 | 3661 | case snd_soc_dapm_micbias: |
| 3655 | 3662 | case snd_soc_dapm_line: |
| @@ -3957,6 +3964,10 @@ snd_soc_dapm_free_kcontrol(struct snd_soc_card *card, · 301 unmodified lines | ||
| 3957 | 3964 | int count; |
| 3958 | 3965 | |
| 3959 | 3966 | devm_kfree(card->dev, (void *)*private_value); |
| 3967 | + | |
| 3968 | + if (!w_param_text) | |
| 3969 | + return; | |
| 3970 | + | |
| 3960 | 3971 | for (count = 0 ; count < num_params; count++) |
| 3961 | 3972 | devm_kfree(card->dev, (void *)w_param_text[count]); |
| 3962 | 3973 | devm_kfree(card->dev, w_param_text); |
| @@ -15,6 +15,7 @@ · 14 unmodified lines | ||
| 15 | 15 | #include <linux/delay.h> |
| 16 | 16 | #include <linux/pinctrl/consumer.h> |
| 17 | 17 | #include <linux/pm_runtime.h> |
| 18 | +#include <linux/module.h> | |
| 18 | 19 | #include <linux/slab.h> |
| 19 | 20 | #include <linux/workqueue.h> |
| 20 | 21 | #include <linux/export.h> |
| @@ -463,6 +464,9 @@ static int soc_pcm_components_close(struct snd_pcm_substream *substream, · 442 unmodified lines | ||
| 463 | 464 | continue; |
| 464 | 465 | |
| 465 | 466 | component->driver->ops->close(substream); |
| 467 | + | |
| 468 | + if (component->driver->module_get_upon_open) | |
| 469 | + module_put(component->dev->driver->owner); | |
| 466 | 470 | } |
| 467 | 471 | |
| 468 | 472 | return 0; |
| @@ -513,6 +517,12 @@ static int soc_pcm_open(struct snd_pcm_substream *substream) · 44 unmodified lines | ||
| 513 | 517 | !component->driver->ops->open) |
| 514 | 518 | continue; |
| 515 | 519 | |
| 520 | + if (component->driver->module_get_upon_open && | |
| 521 | + !try_module_get(component->dev->driver->owner)) { | |
| 522 | + ret = -ENODEV; | |
| 523 | + goto module_err; | |
| 524 | + } | |
| 525 | + | |
| 516 | 526 | ret = component->driver->ops->open(substream); |
| 517 | 527 | if (ret < 0) { |
| 518 | 528 | dev_err(component->dev, |
| @@ -628,7 +638,7 @@ codec_dai_err: · 109 unmodified lines | ||
| 628 | 638 | |
| 629 | 639 | component_err: |
| 630 | 640 | soc_pcm_components_close(substream, component); |
| 631 | − | |
| 641 | +module_err: | |
| 632 | 642 | if (cpu_dai->driver->ops->shutdown) |
| 633 | 643 | cpu_dai->driver->ops->shutdown(substream, cpu_dai); |
| 634 | 644 | out: |
| @@ -954,10 +964,13 @@ static int soc_pcm_hw_params(struct snd_pcm_substream *substream, · 319 unmodified lines | ||
| 954 | 964 | codec_params = *params; |
| 955 | 965 | |
| 956 | 966 | /* fixup params based on TDM slot masks */ |
| 957 | − if (codec_dai->tx_mask) | |
| 967 | + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && | |
| 968 | + codec_dai->tx_mask) | |
| 958 | 969 | soc_pcm_codec_params_fixup(&codec_params, |
| 959 | 970 | codec_dai->tx_mask); |
| 960 | − if (codec_dai->rx_mask) | |
| 971 | + | |
| 972 | + if (substream->stream == SNDRV_PCM_STREAM_CAPTURE && | |
| 973 | + codec_dai->rx_mask) | |
| 961 | 974 | soc_pcm_codec_params_fixup(&codec_params, |
| 962 | 975 | codec_dai->rx_mask); |
| 963 | 976 | |
| @@ -1213,6 +1226,7 @@ static int dpcm_be_connect(struct snd_soc_pcm_runtime *fe, · 249 unmodified lines | ||
| 1213 | 1226 | struct snd_soc_pcm_runtime *be, int stream) |
| 1214 | 1227 | { |
| 1215 | 1228 | struct snd_soc_dpcm *dpcm; |
| 1229 | + unsigned long flags; | |
| 1216 | 1230 | |
| 1217 | 1231 | /* only add new dpcms */ |
| 1218 | 1232 | for_each_dpcm_be(fe, stream, dpcm) { |
| @@ -1228,8 +1242,10 @@ static int dpcm_be_connect(struct snd_soc_pcm_runtime *fe, · 9 unmodified lines | ||
| 1228 | 1242 | dpcm->fe = fe; |
| 1229 | 1243 | be->dpcm[stream].runtime = fe->dpcm[stream].runtime; |
| 1230 | 1244 | dpcm->state = SND_SOC_DPCM_LINK_STATE_NEW; |
| 1245 | + spin_lock_irqsave(&fe->card->dpcm_lock, flags); | |
| 1231 | 1246 | list_add(&dpcm->list_be, &fe->dpcm[stream].be_clients); |
| 1232 | 1247 | list_add(&dpcm->list_fe, &be->dpcm[stream].fe_clients); |
| 1248 | + spin_unlock_irqrestore(&fe->card->dpcm_lock, flags); | |
| 1233 | 1249 | |
| 1234 | 1250 | dev_dbg(fe->dev, "connected new DPCM %s path %s %s %s\n", |
| 1235 | 1251 | stream ? "capture" : "playback", fe->dai_link->name, |
| @@ -1275,6 +1291,7 @@ static void dpcm_be_reparent(struct snd_soc_pcm_runtime *fe, · 39 unmodified lines | ||
| 1275 | 1291 | void dpcm_be_disconnect(struct snd_soc_pcm_runtime *fe, int stream) |
| 1276 | 1292 | { |
| 1277 | 1293 | struct snd_soc_dpcm *dpcm, *d; |
| 1294 | + unsigned long flags; | |
| 1278 | 1295 | |
| 1279 | 1296 | for_each_dpcm_be_safe(fe, stream, dpcm, d) { |
| 1280 | 1297 | dev_dbg(fe->dev, "ASoC: BE %s disconnect check for %s\n", |
| @@ -1294,8 +1311,10 @@ void dpcm_be_disconnect(struct snd_soc_pcm_runtime *fe, int stream) · 13 unmodified lines | ||
| 1294 | 1311 | #ifdef CONFIG_DEBUG_FS |
| 1295 | 1312 | debugfs_remove(dpcm->debugfs_state); |
| 1296 | 1313 | #endif |
| 1314 | + spin_lock_irqsave(&fe->card->dpcm_lock, flags); | |
| 1297 | 1315 | list_del(&dpcm->list_be); |
| 1298 | 1316 | list_del(&dpcm->list_fe); |
| 1317 | + spin_unlock_irqrestore(&fe->card->dpcm_lock, flags); | |
| 1299 | 1318 | kfree(dpcm); |
| 1300 | 1319 | } |
| 1301 | 1320 | } |
| @@ -1547,10 +1566,13 @@ int dpcm_process_paths(struct snd_soc_pcm_runtime *fe, · 245 unmodified lines | ||
| 1547 | 1566 | void dpcm_clear_pending_state(struct snd_soc_pcm_runtime *fe, int stream) |
| 1548 | 1567 | { |
| 1549 | 1568 | struct snd_soc_dpcm *dpcm; |
| 1569 | + unsigned long flags; | |
| 1550 | 1570 | |
| 1571 | + spin_lock_irqsave(&fe->card->dpcm_lock, flags); | |
| 1551 | 1572 | for_each_dpcm_be(fe, stream, dpcm) |
| 1552 | 1573 | dpcm->be->dpcm[stream].runtime_update = |
| 1553 | 1574 | SND_SOC_DPCM_UPDATE_NO; |
| 1575 | + spin_unlock_irqrestore(&fe->card->dpcm_lock, flags); | |
| 1554 | 1576 | } |
| 1555 | 1577 | |
| 1556 | 1578 | static void dpcm_be_dai_startup_unwind(struct snd_soc_pcm_runtime *fe, |
| @@ -1899,10 +1921,15 @@ static int dpcm_apply_symmetry(struct snd_pcm_substream *fe_substream, · 342 unmodified lines | ||
| 1899 | 1921 | struct snd_soc_pcm_runtime *be = dpcm->be; |
| 1900 | 1922 | struct snd_pcm_substream *be_substream = |
| 1901 | 1923 | snd_soc_dpcm_get_substream(be, stream); |
| 1902 | − struct snd_soc_pcm_runtime *rtd = be_substream->private_data; | |
| 1924 | + struct snd_soc_pcm_runtime *rtd; | |
| 1903 | 1925 | struct snd_soc_dai *codec_dai; |
| 1904 | 1926 | int i; |
| 1905 | 1927 | |
| 1928 | + /* A backend may not have the requested substream */ | |
| 1929 | + if (!be_substream) | |
| 1930 | + continue; | |
| 1931 | + | |
| 1932 | + rtd = be_substream->private_data; | |
| 1906 | 1933 | if (rtd->dai_link->be_hw_params_fixup) |
| 1907 | 1934 | continue; |
| 1908 | 1935 | |
| @@ -2571,6 +2598,7 @@ static int dpcm_run_update_startup(struct snd_soc_pcm_runtime *fe, int stream) · 662 unmodified lines | ||
| 2571 | 2598 | struct snd_soc_dpcm *dpcm; |
| 2572 | 2599 | enum snd_soc_dpcm_trigger trigger = fe->dai_link->trigger[stream]; |
| 2573 | 2600 | int ret; |
| 2601 | + unsigned long flags; | |
| 2574 | 2602 | |
| 2575 | 2603 | dev_dbg(fe->dev, "ASoC: runtime %s open on FE %s\n", |
| 2576 | 2604 | stream ? "capture" : "playback", fe->dai_link->name); |
| @@ -2640,11 +2668,13 @@ close: · 63 unmodified lines | ||
| 2640 | 2668 | dpcm_be_dai_shutdown(fe, stream); |
| 2641 | 2669 | disconnect: |
| 2642 | 2670 | /* disconnect any non started BEs */ |
| 2671 | + spin_lock_irqsave(&fe->card->dpcm_lock, flags); | |
| 2643 | 2672 | for_each_dpcm_be(fe, stream, dpcm) { |
| 2644 | 2673 | struct snd_soc_pcm_runtime *be = dpcm->be; |
| 2645 | 2674 | if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_START) |
| 2646 | 2675 | dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE; |
| 2647 | 2676 | } |
| 2677 | + spin_unlock_irqrestore(&fe->card->dpcm_lock, flags); | |
| 2648 | 2678 | |
| 2649 | 2679 | return ret; |
| 2650 | 2680 | } |
| @@ -3221,7 +3251,10 @@ int snd_soc_dpcm_can_be_free_stop(struct snd_soc_pcm_runtime *fe, · 570 unmodified lines | ||
| 3221 | 3251 | { |
| 3222 | 3252 | struct snd_soc_dpcm *dpcm; |
| 3223 | 3253 | int state; |
| 3254 | + int ret = 1; | |
| 3255 | + unsigned long flags; | |
| 3224 | 3256 | |
| 3257 | + spin_lock_irqsave(&fe->card->dpcm_lock, flags); | |
| 3225 | 3258 | for_each_dpcm_fe(be, stream, dpcm) { |
| 3226 | 3259 | |
| 3227 | 3260 | if (dpcm->fe == fe) |
| @@ -3230,12 +3263,15 @@ int snd_soc_dpcm_can_be_free_stop(struct snd_soc_pcm_runtime *fe, · 2 unmodified lines | ||
| 3230 | 3263 | state = dpcm->fe->dpcm[stream].state; |
| 3231 | 3264 | if (state == SND_SOC_DPCM_STATE_START || |
| 3232 | 3265 | state == SND_SOC_DPCM_STATE_PAUSED || |
| 3233 | − state == SND_SOC_DPCM_STATE_SUSPEND) | |
| 3234 | − return 0; | |
| 3266 | + state == SND_SOC_DPCM_STATE_SUSPEND) { | |
| 3267 | + ret = 0; | |
| 3268 | + break; | |
| 3269 | + } | |
| 3235 | 3270 | } |
| 3271 | + spin_unlock_irqrestore(&fe->card->dpcm_lock, flags); | |
| 3236 | 3272 | |
| 3237 | 3273 | /* it's safe to free/stop this BE DAI */ |
| 3238 | − return 1; | |
| 3274 | + return ret; | |
| 3239 | 3275 | } |
| 3240 | 3276 | EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_free_stop); |
| 3241 | 3277 | |
| @@ -3248,7 +3284,10 @@ int snd_soc_dpcm_can_be_params(struct snd_soc_pcm_runtime *fe, · 6 unmodified lines | ||
| 3248 | 3284 | { |
| 3249 | 3285 | struct snd_soc_dpcm *dpcm; |
| 3250 | 3286 | int state; |
| 3287 | + int ret = 1; | |
| 3288 | + unsigned long flags; | |
| 3251 | 3289 | |
| 3290 | + spin_lock_irqsave(&fe->card->dpcm_lock, flags); | |
| 3252 | 3291 | for_each_dpcm_fe(be, stream, dpcm) { |
| 3253 | 3292 | |
| 3254 | 3293 | if (dpcm->fe == fe) |
| @@ -3258,12 +3297,15 @@ int snd_soc_dpcm_can_be_params(struct snd_soc_pcm_runtime *fe, · 3 unmodified lines | ||
| 3258 | 3297 | if (state == SND_SOC_DPCM_STATE_START || |
| 3259 | 3298 | state == SND_SOC_DPCM_STATE_PAUSED || |
| 3260 | 3299 | state == SND_SOC_DPCM_STATE_SUSPEND || |
| 3261 | − state == SND_SOC_DPCM_STATE_PREPARE) | |
| 3262 | − return 0; | |
| 3300 | + state == SND_SOC_DPCM_STATE_PREPARE) { | |
| 3301 | + ret = 0; | |
| 3302 | + break; | |
| 3303 | + } | |
| 3263 | 3304 | } |
| 3305 | + spin_unlock_irqrestore(&fe->card->dpcm_lock, flags); | |
| 3264 | 3306 | |
| 3265 | 3307 | /* it's safe to change hw_params */ |
| 3266 | − return 1; | |
| 3308 | + return ret; | |
| 3267 | 3309 | } |
| 3268 | 3310 | EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_params); |
| 3269 | 3311 | |
| @@ -3302,6 +3344,7 @@ static ssize_t dpcm_show_state(struct snd_soc_pcm_runtime *fe, · 32 unmodified lines | ||
| 3302 | 3344 | struct snd_pcm_hw_params *params = &fe->dpcm[stream].hw_params; |
| 3303 | 3345 | struct snd_soc_dpcm *dpcm; |
| 3304 | 3346 | ssize_t offset = 0; |
| 3347 | + unsigned long flags; | |
| 3305 | 3348 | |
| 3306 | 3349 | /* FE state */ |
| 3307 | 3350 | offset += snprintf(buf + offset, size - offset, |
| @@ -3329,6 +3372,7 @@ static ssize_t dpcm_show_state(struct snd_soc_pcm_runtime *fe, · 21 unmodified lines | ||
| 3329 | 3372 | goto out; |
| 3330 | 3373 | } |
| 3331 | 3374 | |
| 3375 | + spin_lock_irqsave(&fe->card->dpcm_lock, flags); | |
| 3332 | 3376 | for_each_dpcm_be(fe, stream, dpcm) { |
| 3333 | 3377 | struct snd_soc_pcm_runtime *be = dpcm->be; |
| 3334 | 3378 | params = &dpcm->hw_params; |
| @@ -3349,7 +3393,7 @@ static ssize_t dpcm_show_state(struct snd_soc_pcm_runtime *fe, · 14 unmodified lines | ||
| 3349 | 3393 | params_channels(params), |
| 3350 | 3394 | params_rate(params)); |
| 3351 | 3395 | } |
| 3352 | − | |
| 3396 | + spin_unlock_irqrestore(&fe->card->dpcm_lock, flags); | |
| 3353 | 3397 | out: |
| 3354 | 3398 | return offset; |
| 3355 | 3399 | } |
| @@ -482,10 +482,11 @@ static void remove_widget(struct snd_soc_component *comp, · 481 unmodified lines | ||
| 482 | 482 | |
| 483 | 483 | snd_ctl_remove(card, kcontrol); |
| 484 | 484 | |
| 485 | − kfree(dobj->control.dvalues); | |
| 485 | + /* free enum kcontrol's dvalues and dtexts */ | |
| 486 | + kfree(se->dobj.control.dvalues); | |
| 486 | 487 | for (j = 0; j < se->items; j++) |
| 487 | − kfree(dobj->control.dtexts[j]); | |
| 488 | − kfree(dobj->control.dtexts); | |
| 488 | + kfree(se->dobj.control.dtexts[j]); | |
| 489 | + kfree(se->dobj.control.dtexts); | |
| 489 | 490 | |
| 490 | 491 | kfree(se); |
| 491 | 492 | kfree(w->kcontrol_news[i].name); |
| @@ -9,6 +9,7 @@ · 8 unmodified lines | ||
| 9 | 9 | |
| 10 | 10 | #include <linux/clk.h> |
| 11 | 11 | #include <linux/module.h> |
| 12 | +#include <linux/mutex.h> | |
| 12 | 13 | #include <linux/platform_device.h> |
| 13 | 14 | #include <linux/slab.h> |
| 14 | 15 | |
| @@ -37,6 +38,8 @@ struct stm32_adfsdm_priv { · 22 unmodified lines | ||
| 37 | 38 | /* PCM buffer */ |
| 38 | 39 | unsigned char *pcm_buff; |
| 39 | 40 | unsigned int pos; |
| 41 | + | |
| 42 | + struct mutex lock; /* protect against race condition on iio state */ | |
| 40 | 43 | }; |
| 41 | 44 | |
| 42 | 45 | static const struct snd_pcm_hardware stm32_adfsdm_pcm_hw = { |
| @@ -62,10 +65,12 @@ static void stm32_adfsdm_shutdown(struct snd_pcm_substream *substream, · 19 unmodified lines | ||
| 62 | 65 | { |
| 63 | 66 | struct stm32_adfsdm_priv *priv = snd_soc_dai_get_drvdata(dai); |
| 64 | 67 | |
| 68 | + mutex_lock(&priv->lock); | |
| 65 | 69 | if (priv->iio_active) { |
| 66 | 70 | iio_channel_stop_all_cb(priv->iio_cb); |
| 67 | 71 | priv->iio_active = false; |
| 68 | 72 | } |
| 73 | + mutex_unlock(&priv->lock); | |
| 69 | 74 | } |
| 70 | 75 | |
| 71 | 76 | static int stm32_adfsdm_dai_prepare(struct snd_pcm_substream *substream, |
| @@ -74,13 +79,19 @@ static int stm32_adfsdm_dai_prepare(struct snd_pcm_substream *substream, · 2 unmodified lines | ||
| 74 | 79 | struct stm32_adfsdm_priv *priv = snd_soc_dai_get_drvdata(dai); |
| 75 | 80 | int ret; |
| 76 | 81 | |
| 82 | + mutex_lock(&priv->lock); | |
| 83 | + if (priv->iio_active) { | |
| 84 | + iio_channel_stop_all_cb(priv->iio_cb); | |
| 85 | + priv->iio_active = false; | |
| 86 | + } | |
| 87 | + | |
| 77 | 88 | ret = iio_write_channel_attribute(priv->iio_ch, |
| 78 | 89 | substream->runtime->rate, 0, |
| 79 | 90 | IIO_CHAN_INFO_SAMP_FREQ); |
| 80 | 91 | if (ret < 0) { |
| 81 | 92 | dev_err(dai->dev, "%s: Failed to set %d sampling rate\n", |
| 82 | 93 | __func__, substream->runtime->rate); |
| 83 | − return ret; | |
| 94 | + goto out; | |
| 84 | 95 | } |
| 85 | 96 | |
| 86 | 97 | if (!priv->iio_active) { |
| @@ -92,6 +103,9 @@ static int stm32_adfsdm_dai_prepare(struct snd_pcm_substream *substream, · 5 unmodified lines | ||
| 92 | 103 | __func__, ret); |
| 93 | 104 | } |
| 94 | 105 | |
| 106 | +out: | |
| 107 | + mutex_unlock(&priv->lock); | |
| 108 | + | |
| 95 | 109 | return ret; |
| 96 | 110 | } |
| 97 | 111 | |
| @@ -291,6 +305,7 @@ MODULE_DEVICE_TABLE(of, stm32_adfsdm_of_match); · 193 unmodified lines | ||
| 291 | 305 | static int stm32_adfsdm_probe(struct platform_device *pdev) |
| 292 | 306 | { |
| 293 | 307 | struct stm32_adfsdm_priv *priv; |
| 308 | + struct snd_soc_component *component; | |
| 294 | 309 | int ret; |
| 295 | 310 | |
| 296 | 311 | priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); |
| @@ -299,6 +314,7 @@ static int stm32_adfsdm_probe(struct platform_device *pdev) · 2 unmodified lines | ||
| 299 | 314 | |
| 300 | 315 | priv->dev = &pdev->dev; |
| 301 | 316 | priv->dai_drv = stm32_adfsdm_dai; |
| 317 | + mutex_init(&priv->lock); | |
| 302 | 318 | |
| 303 | 319 | dev_set_drvdata(&pdev->dev, priv); |
| 304 | 320 | |
| @@ -317,9 +333,15 @@ static int stm32_adfsdm_probe(struct platform_device *pdev) · 12 unmodified lines | ||
| 317 | 333 | if (IS_ERR(priv->iio_cb)) |
| 318 | 334 | return PTR_ERR(priv->iio_cb); |
| 319 | 335 | |
| 320 | − ret = devm_snd_soc_register_component(&pdev->dev, | |
| 321 | − &stm32_adfsdm_soc_platform, | |
| 322 | − NULL, 0); | |
| 336 | + component = devm_kzalloc(&pdev->dev, sizeof(*component), GFP_KERNEL); | |
| 337 | + if (!component) | |
| 338 | + return -ENOMEM; | |
| 339 | +#ifdef CONFIG_DEBUG_FS | |
| 340 | + component->debugfs_prefix = "pcm"; | |
| 341 | +#endif | |
| 342 | + | |
| 343 | + ret = snd_soc_add_component(&pdev->dev, component, | |
| 344 | + &stm32_adfsdm_soc_platform, NULL, 0); | |
| 323 | 345 | if (ret < 0) |
| 324 | 346 | dev_err(&pdev->dev, "%s: Failed to register PCM platform\n", |
| 325 | 347 | __func__); |
| @@ -327,12 +349,20 @@ static int stm32_adfsdm_probe(struct platform_device *pdev) · 1 unmodified line | ||
| 327 | 349 | return ret; |
| 328 | 350 | } |
| 329 | 351 | |
| 352 | +static int stm32_adfsdm_remove(struct platform_device *pdev) | |
| 353 | +{ | |
| 354 | + snd_soc_unregister_component(&pdev->dev); | |
| 355 | + | |
| 356 | + return 0; | |
| 357 | +} | |
| 358 | + | |
| 330 | 359 | static struct platform_driver stm32_adfsdm_driver = { |
| 331 | 360 | .driver = { |
| 332 | 361 | .name = STM32_ADFSDM_DRV_NAME, |
| 333 | 362 | .of_match_table = stm32_adfsdm_of_match, |
| 334 | 363 | }, |
| 335 | 364 | .probe = stm32_adfsdm_probe, |
| 365 | + .remove = stm32_adfsdm_remove, | |
| 336 | 366 | }; |
| 337 | 367 | |
| 338 | 368 | module_platform_driver(stm32_adfsdm_driver); |
| @@ -281,7 +281,6 @@ static bool stm32_i2s_readable_reg(struct device *dev, unsigned int reg) · 280 unmodified lines | ||
| 281 | 281 | case STM32_I2S_CFG2_REG: |
| 282 | 282 | case STM32_I2S_IER_REG: |
| 283 | 283 | case STM32_I2S_SR_REG: |
| 284 | − case STM32_I2S_TXDR_REG: | |
| 285 | 284 | case STM32_I2S_RXDR_REG: |
| 286 | 285 | case STM32_I2S_CGFR_REG: |
| 287 | 286 | return true; |
| @@ -293,7 +292,7 @@ static bool stm32_i2s_readable_reg(struct device *dev, unsigned int reg) · 5 unmodified lines | ||
| 293 | 292 | static bool stm32_i2s_volatile_reg(struct device *dev, unsigned int reg) |
| 294 | 293 | { |
| 295 | 294 | switch (reg) { |
| 296 | − case STM32_I2S_TXDR_REG: | |
| 295 | + case STM32_I2S_SR_REG: | |
| 297 | 296 | case STM32_I2S_RXDR_REG: |
| 298 | 297 | return true; |
| 299 | 298 | default: |
| @@ -105,6 +105,7 @@ static int stm32_sai_set_sync(struct stm32_sai_data *sai_client, · 104 unmodified lines | ||
| 105 | 105 | if (!pdev) { |
| 106 | 106 | dev_err(&sai_client->pdev->dev, |
| 107 | 107 | "Device not found for node %pOFn\n", np_provider); |
| 108 | + of_node_put(np_provider); | |
| 108 | 109 | return -ENODEV; |
| 109 | 110 | } |
| 110 | 111 | |
| @@ -113,19 +114,20 @@ static int stm32_sai_set_sync(struct stm32_sai_data *sai_client, · 2 unmodified lines | ||
| 113 | 114 | dev_err(&sai_client->pdev->dev, |
| 114 | 115 | "SAI sync provider data not found\n"); |
| 115 | 116 | ret = -EINVAL; |
| 116 | − goto out_put_dev; | |
| 117 | + goto error; | |
| 117 | 118 | } |
| 118 | 119 | |
| 119 | 120 | /* Configure sync client */ |
| 120 | 121 | ret = stm32_sai_sync_conf_client(sai_client, synci); |
| 121 | 122 | if (ret < 0) |
| 122 | − goto out_put_dev; | |
| 123 | + goto error; | |
| 123 | 124 | |
| 124 | 125 | /* Configure sync provider */ |
| 125 | 126 | ret = stm32_sai_sync_conf_provider(sai_provider, synco); |
| 126 | 127 | |
| 127 | −out_put_dev: | |
| 128 | +error: | |
| 128 | 129 | put_device(&pdev->dev); |
| 130 | + of_node_put(np_provider); | |
| 129 | 131 | return ret; |
| 130 | 132 | } |
| 131 | 133 | |
| @@ -70,6 +70,7 @@ · 69 unmodified lines | ||
| 70 | 70 | #define SAI_IEC60958_STATUS_BYTES 24 |
| 71 | 71 | |
| 72 | 72 | #define SAI_MCLK_NAME_LEN 32 |
| 73 | +#define SAI_RATE_11K 11025 | |
| 73 | 74 | |
| 74 | 75 | /** |
| 75 | 76 | * struct stm32_sai_sub_data - private data of SAI sub block (block A or B) |
| @@ -100,8 +101,9 @@ · 24 unmodified lines | ||
| 100 | 101 | * @slot_mask: rx or tx active slots mask. set at init or at runtime |
| 101 | 102 | * @data_size: PCM data width. corresponds to PCM substream width. |
| 102 | 103 | * @spdif_frm_cnt: S/PDIF playback frame counter |
| 103 | − * @snd_aes_iec958: iec958 data | |
| 104 | + * @iec958: iec958 data | |
| 104 | 105 | * @ctrl_lock: control lock |
| 106 | + * @irq_lock: prevent race condition with IRQ | |
| 105 | 107 | */ |
| 106 | 108 | struct stm32_sai_sub_data { |
| 107 | 109 | struct platform_device *pdev; |
| @@ -133,6 +135,7 @@ struct stm32_sai_sub_data { · 25 unmodified lines | ||
| 133 | 135 | unsigned int spdif_frm_cnt; |
| 134 | 136 | struct snd_aes_iec958 iec958; |
| 135 | 137 | struct mutex ctrl_lock; /* protect resources accessed by controls */ |
| 138 | + spinlock_t irq_lock; /* used to prevent race condition with IRQ */ | |
| 136 | 139 | }; |
| 137 | 140 | |
| 138 | 141 | enum stm32_sai_fifo_th { |
| @@ -307,6 +310,25 @@ static int stm32_sai_set_clk_div(struct stm32_sai_sub_data *sai, · 168 unmodified lines | ||
| 307 | 310 | return ret; |
| 308 | 311 | } |
| 309 | 312 | |
| 313 | +static int stm32_sai_set_parent_clock(struct stm32_sai_sub_data *sai, | |
| 314 | + unsigned int rate) | |
| 315 | +{ | |
| 316 | + struct platform_device *pdev = sai->pdev; | |
| 317 | + struct clk *parent_clk = sai->pdata->clk_x8k; | |
| 318 | + int ret; | |
| 319 | + | |
| 320 | + if (!(rate % SAI_RATE_11K)) | |
| 321 | + parent_clk = sai->pdata->clk_x11k; | |
| 322 | + | |
| 323 | + ret = clk_set_parent(sai->sai_ck, parent_clk); | |
| 324 | + if (ret) | |
| 325 | + dev_err(&pdev->dev, " Error %d setting sai_ck parent clock. %s", | |
| 326 | + ret, ret == -EBUSY ? | |
| 327 | + "Active stream rates conflict\n" : "\n"); | |
| 328 | + | |
| 329 | + return ret; | |
| 330 | +} | |
| 331 | + | |
| 310 | 332 | static long stm32_sai_mclk_round_rate(struct clk_hw *hw, unsigned long rate, |
| 311 | 333 | unsigned long *prate) |
| 312 | 334 | { |
| @@ -474,8 +496,10 @@ static irqreturn_t stm32_sai_isr(int irq, void *devid) · 161 unmodified lines | ||
| 474 | 496 | status = SNDRV_PCM_STATE_XRUN; |
| 475 | 497 | } |
| 476 | 498 | |
| 477 | − if (status != SNDRV_PCM_STATE_RUNNING) | |
| 499 | + spin_lock(&sai->irq_lock); | |
| 500 | + if (status != SNDRV_PCM_STATE_RUNNING && sai->substream) | |
| 478 | 501 | snd_pcm_stop_xrun(sai->substream); |
| 502 | + spin_unlock(&sai->irq_lock); | |
| 479 | 503 | |
| 480 | 504 | return IRQ_HANDLED; |
| 481 | 505 | } |
| @@ -486,25 +510,29 @@ static int stm32_sai_set_sysclk(struct snd_soc_dai *cpu_dai, · 4 unmodified lines | ||
| 486 | 510 | struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai); |
| 487 | 511 | int ret; |
| 488 | 512 | |
| 489 | − if (dir == SND_SOC_CLOCK_OUT) { | |
| 513 | + if (dir == SND_SOC_CLOCK_OUT && sai->sai_mclk) { | |
| 490 | 514 | ret = regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX, |
| 491 | 515 | SAI_XCR1_NODIV, |
| 492 | 516 | (unsigned int)~SAI_XCR1_NODIV); |
| 493 | 517 | if (ret < 0) |
| 494 | 518 | return ret; |
| 495 | 519 | |
| 496 | − dev_dbg(cpu_dai->dev, "SAI MCLK frequency is %uHz\n", freq); | |
| 497 | − sai->mclk_rate = freq; | |
| 520 | + /* If master clock is used, set parent clock now */ | |
| 521 | + ret = stm32_sai_set_parent_clock(sai, freq); | |
| 522 | + if (ret) | |
| 523 | + return ret; | |
| 498 | 524 | |
| 499 | − if (sai->sai_mclk) { | |
| 500 | − ret = clk_set_rate_exclusive(sai->sai_mclk, | |
| 501 | − sai->mclk_rate); | |
| 502 | − if (ret) { | |
| 503 | − dev_err(cpu_dai->dev, | |
| 504 | − "Could not set mclk rate\n"); | |
| 505 | − return ret; | |
| 506 | − } | |
| 525 | + ret = clk_set_rate_exclusive(sai->sai_mclk, freq); | |
| 526 | + if (ret) { | |
| 527 | + dev_err(cpu_dai->dev, | |
| 528 | + ret == -EBUSY ? | |
| 529 | + "Active streams have incompatible rates" : | |
| 530 | + "Could not set mclk rate\n"); | |
| 531 | + return ret; | |
| 507 | 532 | } |
| 533 | + | |
| 534 | + dev_dbg(cpu_dai->dev, "SAI MCLK frequency is %uHz\n", freq); | |
| 535 | + sai->mclk_rate = freq; | |
| 508 | 536 | } |
| 509 | 537 | |
| 510 | 538 | return 0; |
| @@ -679,8 +707,19 @@ static int stm32_sai_startup(struct snd_pcm_substream *substream, · 168 unmodified lines | ||
| 679 | 707 | { |
| 680 | 708 | struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai); |
| 681 | 709 | int imr, cr2, ret; |
| 710 | + unsigned long flags; | |
| 682 | 711 | |
| 712 | + spin_lock_irqsave(&sai->irq_lock, flags); | |
| 683 | 713 | sai->substream = substream; |
| 714 | + spin_unlock_irqrestore(&sai->irq_lock, flags); | |
| 715 | + | |
| 716 | + if (STM_SAI_PROTOCOL_IS_SPDIF(sai)) { | |
| 717 | + snd_pcm_hw_constraint_mask64(substream->runtime, | |
| 718 | + SNDRV_PCM_HW_PARAM_FORMAT, | |
| 719 | + SNDRV_PCM_FMTBIT_S32_LE); | |
| 720 | + snd_pcm_hw_constraint_single(substream->runtime, | |
| 721 | + SNDRV_PCM_HW_PARAM_CHANNELS, 2); | |
| 722 | + } | |
| 684 | 723 | |
| 685 | 724 | ret = clk_prepare_enable(sai->sai_ck); |
| 686 | 725 | if (ret < 0) { |
| @@ -898,14 +937,16 @@ static int stm32_sai_configure_clock(struct snd_soc_dai *cpu_dai, · 211 unmodified lines | ||
| 898 | 937 | struct snd_pcm_hw_params *params) |
| 899 | 938 | { |
| 900 | 939 | struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai); |
| 901 | − int div = 0; | |
| 940 | + int div = 0, cr1 = 0; | |
| 902 | 941 | int sai_clk_rate, mclk_ratio, den; |
| 903 | 942 | unsigned int rate = params_rate(params); |
| 943 | + int ret; | |
| 904 | 944 | |
| 905 | − if (!(rate % 11025)) | |
| 906 | − clk_set_parent(sai->sai_ck, sai->pdata->clk_x11k); | |
| 907 | − else | |
| 908 | − clk_set_parent(sai->sai_ck, sai->pdata->clk_x8k); | |
| 945 | + if (!sai->sai_mclk) { | |
| 946 | + ret = stm32_sai_set_parent_clock(sai, rate); | |
| 947 | + if (ret) | |
| 948 | + return ret; | |
| 949 | + } | |
| 909 | 950 | sai_clk_rate = clk_get_rate(sai->sai_ck); |
| 910 | 951 | |
| 911 | 952 | if (STM_SAI_IS_F4(sai->pdata)) { |
| @@ -943,13 +984,19 @@ static int stm32_sai_configure_clock(struct snd_soc_dai *cpu_dai, · 31 unmodified lines | ||
| 943 | 984 | } else { |
| 944 | 985 | if (sai->mclk_rate) { |
| 945 | 986 | mclk_ratio = sai->mclk_rate / rate; |
| 946 | − if ((mclk_ratio != 512) && | |
| 947 | − (mclk_ratio != 256)) { | |
| 987 | + if (mclk_ratio == 512) { | |
| 988 | + cr1 = SAI_XCR1_OSR; | |
| 989 | + } else if (mclk_ratio != 256) { | |
| 948 | 990 | dev_err(cpu_dai->dev, |
| 949 | 991 | "Wrong mclk ratio %d\n", |
| 950 | 992 | mclk_ratio); |
| 951 | 993 | return -EINVAL; |
| 952 | 994 | } |
| 995 | + | |
| 996 | + regmap_update_bits(sai->regmap, | |
| 997 | + STM_SAI_CR1_REGX, | |
| 998 | + SAI_XCR1_OSR, cr1); | |
| 999 | + | |
| 953 | 1000 | div = stm32_sai_get_clk_div(sai, sai_clk_rate, |
| 954 | 1001 | sai->mclk_rate); |
| 955 | 1002 | if (div < 0) |
| @@ -1051,28 +1098,36 @@ static void stm32_sai_shutdown(struct snd_pcm_substream *substream, · 95 unmodified lines | ||
| 1051 | 1098 | struct snd_soc_dai *cpu_dai) |
| 1052 | 1099 | { |
| 1053 | 1100 | struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai); |
| 1101 | + unsigned long flags; | |
| 1054 | 1102 | |
| 1055 | 1103 | regmap_update_bits(sai->regmap, STM_SAI_IMR_REGX, SAI_XIMR_MASK, 0); |
| 1056 | 1104 | |
| 1057 | 1105 | regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX, SAI_XCR1_NODIV, |
| 1058 | 1106 | SAI_XCR1_NODIV); |
| 1059 | 1107 | |
| 1060 | − clk_disable_unprepare(sai->sai_ck); | |
| 1108 | + /* Release mclk rate only if rate was actually set */ | |
| 1109 | + if (sai->mclk_rate) { | |
| 1110 | + clk_rate_exclusive_put(sai->sai_mclk); | |
| 1111 | + sai->mclk_rate = 0; | |
| 1112 | + } | |
| 1061 | 1113 | |
| 1062 | − clk_rate_exclusive_put(sai->sai_mclk); | |
| 1114 | + clk_disable_unprepare(sai->sai_ck); | |
| 1063 | 1115 | |
| 1116 | + spin_lock_irqsave(&sai->irq_lock, flags); | |
| 1064 | 1117 | sai->substream = NULL; |
| 1118 | + spin_unlock_irqrestore(&sai->irq_lock, flags); | |
| 1065 | 1119 | } |
| 1066 | 1120 | |
| 1067 | 1121 | static int stm32_sai_pcm_new(struct snd_soc_pcm_runtime *rtd, |
| 1068 | 1122 | struct snd_soc_dai *cpu_dai) |
| 1069 | 1123 | { |
| 1070 | 1124 | struct stm32_sai_sub_data *sai = dev_get_drvdata(cpu_dai->dev); |
| 1125 | + struct snd_kcontrol_new knew = iec958_ctls; | |
| 1071 | 1126 | |
| 1072 | 1127 | if (STM_SAI_PROTOCOL_IS_SPDIF(sai)) { |
| 1073 | 1128 | dev_dbg(&sai->pdev->dev, "%s: register iec controls", __func__); |
| 1074 | − return snd_ctl_add(rtd->pcm->card, | |
| 1075 | − snd_ctl_new1(&iec958_ctls, sai)); | |
| 1129 | + knew.device = rtd->pcm->device; | |
| 1130 | + return snd_ctl_add(rtd->pcm->card, snd_ctl_new1(&knew, sai)); | |
| 1076 | 1131 | } |
| 1077 | 1132 | |
| 1078 | 1133 | return 0; |
| @@ -1081,7 +1136,7 @@ static int stm32_sai_pcm_new(struct snd_soc_pcm_runtime *rtd, · 2 unmodified lines | ||
| 1081 | 1136 | static int stm32_sai_dai_probe(struct snd_soc_dai *cpu_dai) |
| 1082 | 1137 | { |
| 1083 | 1138 | struct stm32_sai_sub_data *sai = dev_get_drvdata(cpu_dai->dev); |
| 1084 | − int cr1 = 0, cr1_mask; | |
| 1139 | + int cr1 = 0, cr1_mask, ret; | |
| 1085 | 1140 | |
| 1086 | 1141 | sai->cpu_dai = cpu_dai; |
| 1087 | 1142 | |
| @@ -1111,8 +1166,10 @@ static int stm32_sai_dai_probe(struct snd_soc_dai *cpu_dai) · 23 unmodified lines | ||
| 1111 | 1166 | /* Configure synchronization */ |
| 1112 | 1167 | if (sai->sync == SAI_SYNC_EXTERNAL) { |
| 1113 | 1168 | /* Configure synchro client and provider */ |
| 1114 | − sai->pdata->set_sync(sai->pdata, sai->np_sync_provider, | |
| 1115 | − sai->synco, sai->synci); | |
| 1169 | + ret = sai->pdata->set_sync(sai->pdata, sai->np_sync_provider, | |
| 1170 | + sai->synco, sai->synci); | |
| 1171 | + if (ret) | |
| 1172 | + return ret; | |
| 1116 | 1173 | } |
| 1117 | 1174 | |
| 1118 | 1175 | cr1_mask |= SAI_XCR1_SYNCEN_MASK; |
| @@ -1392,7 +1449,6 @@ static int stm32_sai_sub_dais_init(struct platform_device *pdev, · 273 unmodified lines | ||
| 1392 | 1449 | if (!sai->cpu_dai_drv) |
| 1393 | 1450 | return -ENOMEM; |
| 1394 | 1451 | |
| 1395 | − sai->cpu_dai_drv->name = dev_name(&pdev->dev); | |
| 1396 | 1452 | if (STM_SAI_IS_PLAYBACK(sai)) { |
| 1397 | 1453 | memcpy(sai->cpu_dai_drv, &stm32_sai_playback_dai, |
| 1398 | 1454 | sizeof(stm32_sai_playback_dai)); |
| @@ -1402,6 +1458,7 @@ static int stm32_sai_sub_dais_init(struct platform_device *pdev, · 3 unmodified lines | ||
| 1402 | 1458 | sizeof(stm32_sai_capture_dai)); |
| 1403 | 1459 | sai->cpu_dai_drv->capture.stream_name = sai->cpu_dai_drv->name; |
| 1404 | 1460 | } |
| 1461 | + sai->cpu_dai_drv->name = dev_name(&pdev->dev); | |
| 1405 | 1462 | |
| 1406 | 1463 | return 0; |
| 1407 | 1464 | } |
| @@ -1424,6 +1481,7 @@ static int stm32_sai_sub_probe(struct platform_device *pdev) · 16 unmodified lines | ||
| 1424 | 1481 | |
| 1425 | 1482 | sai->pdev = pdev; |
| 1426 | 1483 | mutex_init(&sai->ctrl_lock); |
| 1484 | + spin_lock_init(&sai->irq_lock); | |
| 1427 | 1485 | platform_set_drvdata(pdev, sai); |
| 1428 | 1486 | |
| 1429 | 1487 | sai->pdata = dev_get_drvdata(pdev->dev.parent); |
| @@ -441,7 +441,7 @@ static int shbuf_setup_backstore(struct xen_snd_front_pcm_stream_info *stream, · 440 unmodified lines | ||
| 441 | 441 | { |
| 442 | 442 | int i; |
| 443 | 443 | |
| 444 | − stream->buffer = alloc_pages_exact(stream->buffer_sz, GFP_KERNEL); | |
| 444 | + stream->buffer = alloc_pages_exact(buffer_sz, GFP_KERNEL); | |
| 445 | 445 | if (!stream->buffer) |
| 446 | 446 | return -ENOMEM; |
| 447 | 447 | |
| @@ -32,10 +32,6 @@ · 31 unmodified lines | ||
| 32 | 32 | #include "liburing.h" |
| 33 | 33 | #include "barrier.h" |
| 34 | 34 | |
| 35 | −#ifndef IOCQE_FLAG_CACHEHIT | |
| 36 | −#define IOCQE_FLAG_CACHEHIT (1U << 0) | |
| 37 | −#endif | |
| 38 | − | |
| 39 | 35 | #define min(a, b) ((a < b) ? (a) : (b)) |
| 40 | 36 | |
| 41 | 37 | struct io_sq_ring { |
| @@ -85,7 +81,6 @@ struct submitter { · 43 unmodified lines | ||
| 85 | 81 | unsigned long reaps; |
| 86 | 82 | unsigned long done; |
| 87 | 83 | unsigned long calls; |
| 88 | − unsigned long cachehit, cachemiss; | |
| 89 | 84 | volatile int finish; |
| 90 | 85 | |
| 91 | 86 | __s32 *fds; |
| @@ -270,10 +265,6 @@ static int reap_events(struct submitter *s) · 178 unmodified lines | ||
| 270 | 265 | return -1; |
| 271 | 266 | } |
| 272 | 267 | } |
| 273 | − if (cqe->flags & IOCQE_FLAG_CACHEHIT) | |
| 274 | − s->cachehit++; | |
| 275 | − else | |
| 276 | − s->cachemiss++; | |
| 277 | 268 | reaped++; |
| 278 | 269 | head++; |
| 279 | 270 | } while (1); |
| @@ -489,7 +480,7 @@ static void file_depths(char *buf) · 209 unmodified lines | ||
| 489 | 480 | int main(int argc, char *argv[]) |
| 490 | 481 | { |
| 491 | 482 | struct submitter *s = &submitters[0]; |
| 492 | − unsigned long done, calls, reap, cache_hit, cache_miss; | |
| 483 | + unsigned long done, calls, reap; | |
| 493 | 484 | int err, i, flags, fd; |
| 494 | 485 | char *fdepths; |
| 495 | 486 | void *ret; |
| @@ -569,44 +560,29 @@ int main(int argc, char *argv[]) · 73 unmodified lines | ||
| 569 | 560 | pthread_create(&s->thread, NULL, submitter_fn, s); |
| 570 | 561 | |
| 571 | 562 | fdepths = malloc(8 * s->nr_files); |
| 572 | − cache_hit = cache_miss = reap = calls = done = 0; | |
| 563 | + reap = calls = done = 0; | |
| 573 | 564 | do { |
| 574 | 565 | unsigned long this_done = 0; |
| 575 | 566 | unsigned long this_reap = 0; |
| 576 | 567 | unsigned long this_call = 0; |
| 577 | − unsigned long this_cache_hit = 0; | |
| 578 | − unsigned long this_cache_miss = 0; | |
| 579 | 568 | unsigned long rpc = 0, ipc = 0; |
| 580 | − double hit = 0.0; | |
| 581 | 569 | |
| 582 | 570 | sleep(1); |
| 583 | 571 | this_done += s->done; |
| 584 | 572 | this_call += s->calls; |
| 585 | 573 | this_reap += s->reaps; |
| 586 | − this_cache_hit += s->cachehit; | |
| 587 | − this_cache_miss += s->cachemiss; | |
| 588 | − if (this_cache_hit && this_cache_miss) { | |
| 589 | − unsigned long hits, total; | |
| 590 | − | |
| 591 | − hits = this_cache_hit - cache_hit; | |
| 592 | − total = hits + this_cache_miss - cache_miss; | |
| 593 | − hit = (double) hits / (double) total; | |
| 594 | − hit *= 100.0; | |
| 595 | − } | |
| 596 | 574 | if (this_call - calls) { |
| 597 | 575 | rpc = (this_done - done) / (this_call - calls); |
| 598 | 576 | ipc = (this_reap - reap) / (this_call - calls); |
| 599 | 577 | } else |
| 600 | 578 | rpc = ipc = -1; |
| 601 | 579 | file_depths(fdepths); |
| 602 | − printf("IOPS=%lu, IOS/call=%ld/%ld, inflight=%u (%s), Cachehit=%0.2f%%\n", | |
| 580 | + printf("IOPS=%lu, IOS/call=%ld/%ld, inflight=%u (%s)\n", | |
| 603 | 581 | this_done - done, rpc, ipc, s->inflight, |
| 604 | − fdepths, hit); | |
| 582 | + fdepths); | |
| 605 | 583 | done = this_done; |
| 606 | 584 | calls = this_call; |
| 607 | 585 | reap = this_reap; |
| 608 | − cache_hit = s->cachehit; | |
| 609 | − cache_miss = s->cachemiss; | |
| 610 | 586 | } while (!finish); |
| 611 | 587 | |
| 612 | 588 | pthread_join(s->thread, &ret); |
| @@ -165,6 +165,7 @@ static int __dead_end_function(struct objtool_file *file, struct symbol *func, · 164 unmodified lines | ||
| 165 | 165 | "fortify_panic", |
| 166 | 166 | "usercopy_abort", |
| 167 | 167 | "machine_real_restart", |
| 168 | + "rewind_stack_do_exit", | |
| 168 | 169 | }; |
| 169 | 170 | |
| 170 | 171 | if (func->bind == STB_WEAK) |
| @@ -146,6 +146,7 @@ static int dimm_fail_cmd_code[ARRAY_SIZE(handle)]; · 145 unmodified lines | ||
| 146 | 146 | struct nfit_test_sec { |
| 147 | 147 | u8 state; |
| 148 | 148 | u8 ext_state; |
| 149 | + u8 old_state; | |
| 149 | 150 | u8 passphrase[32]; |
| 150 | 151 | u8 master_passphrase[32]; |
| 151 | 152 | u64 overwrite_end_time; |
| @@ -225,6 +226,8 @@ static struct workqueue_struct *nfit_wq; · 73 unmodified lines | ||
| 225 | 226 | |
| 226 | 227 | static struct gen_pool *nfit_pool; |
| 227 | 228 | |
| 229 | +static const char zero_key[NVDIMM_PASSPHRASE_LEN]; | |
| 230 | + | |
| 228 | 231 | static struct nfit_test *to_nfit_test(struct device *dev) |
| 229 | 232 | { |
| 230 | 233 | struct platform_device *pdev = to_platform_device(dev); |
| @@ -1059,8 +1062,7 @@ static int nd_intel_test_cmd_secure_erase(struct nfit_test *t, · 828 unmodified lines | ||
| 1059 | 1062 | struct device *dev = &t->pdev.dev; |
| 1060 | 1063 | struct nfit_test_sec *sec = &dimm_sec_info[dimm]; |
| 1061 | 1064 | |
| 1062 | − if (!(sec->state & ND_INTEL_SEC_STATE_ENABLED) || | |
| 1063 | − (sec->state & ND_INTEL_SEC_STATE_FROZEN)) { | |
| 1065 | + if (sec->state & ND_INTEL_SEC_STATE_FROZEN) { | |
| 1064 | 1066 | nd_cmd->status = ND_INTEL_STATUS_INVALID_STATE; |
| 1065 | 1067 | dev_dbg(dev, "secure erase: wrong security state\n"); |
| 1066 | 1068 | } else if (memcmp(nd_cmd->passphrase, sec->passphrase, |
| @@ -1068,6 +1070,12 @@ static int nd_intel_test_cmd_secure_erase(struct nfit_test *t, · 1 unmodified line | ||
| 1068 | 1070 | nd_cmd->status = ND_INTEL_STATUS_INVALID_PASS; |
| 1069 | 1071 | dev_dbg(dev, "secure erase: wrong passphrase\n"); |
| 1070 | 1072 | } else { |
| 1073 | + if (!(sec->state & ND_INTEL_SEC_STATE_ENABLED) | |
| 1074 | + && (memcmp(nd_cmd->passphrase, zero_key, | |
| 1075 | + ND_INTEL_PASSPHRASE_SIZE) != 0)) { | |
| 1076 | + dev_dbg(dev, "invalid zero key\n"); | |
| 1077 | + return 0; | |
| 1078 | + } | |
| 1071 | 1079 | memset(sec->passphrase, 0, ND_INTEL_PASSPHRASE_SIZE); |
| 1072 | 1080 | memset(sec->master_passphrase, 0, ND_INTEL_PASSPHRASE_SIZE); |
| 1073 | 1081 | sec->state = 0; |
| @@ -1093,7 +1101,7 @@ static int nd_intel_test_cmd_overwrite(struct nfit_test *t, · 19 unmodified lines | ||
| 1093 | 1101 | return 0; |
| 1094 | 1102 | } |
| 1095 | 1103 | |
| 1096 | − memset(sec->passphrase, 0, ND_INTEL_PASSPHRASE_SIZE); | |
| 1104 | + sec->old_state = sec->state; | |
| 1097 | 1105 | sec->state = ND_INTEL_SEC_STATE_OVERWRITE; |
| 1098 | 1106 | dev_dbg(dev, "overwrite progressing.\n"); |
| 1099 | 1107 | sec->overwrite_end_time = get_jiffies_64() + 5 * HZ; |
| @@ -1115,7 +1123,8 @@ static int nd_intel_test_cmd_query_overwrite(struct nfit_test *t, · 15 unmodified lines | ||
| 1115 | 1123 | |
| 1116 | 1124 | if (time_is_before_jiffies64(sec->overwrite_end_time)) { |
| 1117 | 1125 | sec->overwrite_end_time = 0; |
| 1118 | − sec->state = 0; | |
| 1126 | + sec->state = sec->old_state; | |
| 1127 | + sec->old_state = 0; | |
| 1119 | 1128 | sec->ext_state = ND_INTEL_SEC_ESTATE_ENABLED; |
| 1120 | 1129 | dev_dbg(dev, "overwrite is complete\n"); |
| 1121 | 1130 | } else |
| @@ -11,6 +11,7 @@ lib_dir=$(dirname $0)/../../../net/forwarding · 10 unmodified lines | ||
| 11 | 11 | |
| 12 | 12 | ALL_TESTS=" |
| 13 | 13 | rif_set_addr_test |
| 14 | + rif_vrf_set_addr_test | |
| 14 | 15 | rif_inherit_bridge_addr_test |
| 15 | 16 | rif_non_inherit_bridge_addr_test |
| 16 | 17 | vlan_interface_deletion_test |
| @@ -99,6 +100,25 @@ rif_set_addr_test() · 82 unmodified lines | ||
| 99 | 100 | ip link set dev $swp1 addr $swp1_mac |
| 100 | 101 | } |
| 101 | 102 | |
| 103 | +rif_vrf_set_addr_test() | |
| 104 | +{ | |
| 105 | + # Test that it is possible to set an IP address on a VRF upper despite | |
| 106 | + # its random MAC address. | |
| 107 | + RET=0 | |
| 108 | + | |
| 109 | + ip link add name vrf-test type vrf table 10 | |
| 110 | + ip link set dev $swp1 master vrf-test | |
| 111 | + | |
| 112 | + ip -4 address add 192.0.2.1/24 dev vrf-test | |
| 113 | + check_err $? "failed to set IPv4 address on VRF" | |
| 114 | + ip -6 address add 2001:db8:1::1/64 dev vrf-test | |
| 115 | + check_err $? "failed to set IPv6 address on VRF" | |
| 116 | + | |
| 117 | + log_test "RIF - setting IP address on VRF" | |
| 118 | + | |
| 119 | + ip link del dev vrf-test | |
| 120 | +} | |
| 121 | + | |
| 102 | 122 | rif_inherit_bridge_addr_test() |
| 103 | 123 | { |
| 104 | 124 | RET=0 |
| @@ -1,3 +1,5 @@ | ||
| 1 | +include ../../../../scripts/Kbuild.include | |
| 2 | + | |
| 1 | 3 | all: |
| 2 | 4 | |
| 3 | 5 | top_srcdir = ../../../.. |
| @@ -17,6 +19,7 @@ TEST_GEN_PROGS_x86_64 += x86_64/state_test · 13 unmodified lines | ||
| 17 | 19 | TEST_GEN_PROGS_x86_64 += x86_64/evmcs_test |
| 18 | 20 | TEST_GEN_PROGS_x86_64 += x86_64/hyperv_cpuid |
| 19 | 21 | TEST_GEN_PROGS_x86_64 += x86_64/vmx_close_while_nested_test |
| 22 | +TEST_GEN_PROGS_x86_64 += x86_64/smm_test | |
| 20 | 23 | TEST_GEN_PROGS_x86_64 += dirty_log_test |
| 21 | 24 | TEST_GEN_PROGS_x86_64 += clear_dirty_log_test |
| 22 | 25 | |
| @@ -30,7 +33,11 @@ INSTALL_HDR_PATH = $(top_srcdir)/usr · 7 unmodified lines | ||
| 30 | 33 | LINUX_HDR_PATH = $(INSTALL_HDR_PATH)/include/ |
| 31 | 34 | LINUX_TOOL_INCLUDE = $(top_srcdir)/tools/include |
| 32 | 35 | CFLAGS += -O2 -g -std=gnu99 -fno-stack-protector -fno-PIE -I$(LINUX_TOOL_INCLUDE) -I$(LINUX_HDR_PATH) -Iinclude -I$(<D) -Iinclude/$(UNAME_M) -I.. |
| 33 | −LDFLAGS += -pthread -no-pie | |
| 36 | + | |
| 37 | +no-pie-option := $(call try-run, echo 'int main() { return 0; }' | \ | |
| 38 | + $(CC) -Werror $(KBUILD_CPPFLAGS) $(CC_OPTION_CFLAGS) -no-pie -x c - -o "$$TMP", -no-pie) | |
| 39 | + | |
| 40 | +LDFLAGS += -pthread $(no-pie-option) | |
| 34 | 41 | |
| 35 | 42 | # After inclusion, $(OUTPUT) is defined and |
| 36 | 43 | # $(TEST_GEN_PROGS) starts with $(OUTPUT)/ |
| @@ -778,6 +778,33 @@ void vcpu_set_msr(struct kvm_vm *vm, uint32_t vcpuid, uint64_t msr_index, · 777 unmodified lines | ||
| 778 | 778 | #define MSR_IA32_APICBASE_ENABLE (1<<11) |
| 779 | 779 | #define MSR_IA32_APICBASE_BASE (0xfffff<<12) |
| 780 | 780 | |
| 781 | +#define APIC_BASE_MSR 0x800 | |
| 782 | +#define X2APIC_ENABLE (1UL << 10) | |
| 783 | +#define APIC_ICR 0x300 | |
| 784 | +#define APIC_DEST_SELF 0x40000 | |
| 785 | +#define APIC_DEST_ALLINC 0x80000 | |
| 786 | +#define APIC_DEST_ALLBUT 0xC0000 | |
| 787 | +#define APIC_ICR_RR_MASK 0x30000 | |
| 788 | +#define APIC_ICR_RR_INVALID 0x00000 | |
| 789 | +#define APIC_ICR_RR_INPROG 0x10000 | |
| 790 | +#define APIC_ICR_RR_VALID 0x20000 | |
| 791 | +#define APIC_INT_LEVELTRIG 0x08000 | |
| 792 | +#define APIC_INT_ASSERT 0x04000 | |
| 793 | +#define APIC_ICR_BUSY 0x01000 | |
| 794 | +#define APIC_DEST_LOGICAL 0x00800 | |
| 795 | +#define APIC_DEST_PHYSICAL 0x00000 | |
| 796 | +#define APIC_DM_FIXED 0x00000 | |
| 797 | +#define APIC_DM_FIXED_MASK 0x00700 | |
| 798 | +#define APIC_DM_LOWEST 0x00100 | |
| 799 | +#define APIC_DM_SMI 0x00200 | |
| 800 | +#define APIC_DM_REMRD 0x00300 | |
| 801 | +#define APIC_DM_NMI 0x00400 | |
| 802 | +#define APIC_DM_INIT 0x00500 | |
| 803 | +#define APIC_DM_STARTUP 0x00600 | |
| 804 | +#define APIC_DM_EXTINT 0x00700 | |
| 805 | +#define APIC_VECTOR_MASK 0x000FF | |
| 806 | +#define APIC_ICR2 0x310 | |
| 807 | + | |
| 781 | 808 | #define MSR_IA32_TSCDEADLINE 0x000006e0 |
| 782 | 809 | |
| 783 | 810 | #define MSR_IA32_UCODE_WRITE 0x00000079 |
| @@ -91,6 +91,11 @@ static void vm_open(struct kvm_vm *vm, int perm, unsigned long type) · 90 unmodified lines | ||
| 91 | 91 | if (vm->kvm_fd < 0) |
| 92 | 92 | exit(KSFT_SKIP); |
| 93 | 93 | |
| 94 | + if (!kvm_check_cap(KVM_CAP_IMMEDIATE_EXIT)) { | |
| 95 | + fprintf(stderr, "immediate_exit not available, skipping test\n"); | |
| 96 | + exit(KSFT_SKIP); | |
| 97 | + } | |
| 98 | + | |
| 94 | 99 | vm->fd = ioctl(vm->kvm_fd, KVM_CREATE_VM, type); |
| 95 | 100 | TEST_ASSERT(vm->fd >= 0, "KVM_CREATE_VM ioctl failed, " |
| 96 | 101 | "rc: %i errno: %i", vm->fd, errno); |
| @@ -1030,6 +1030,14 @@ struct kvm_x86_state *vcpu_save_state(struct kvm_vm *vm, uint32_t vcpuid) · 1029 unmodified lines | ||
| 1030 | 1030 | nested_size, sizeof(state->nested_)); |
| 1031 | 1031 | } |
| 1032 | 1032 | |
| 1033 | + /* | |
| 1034 | + * When KVM exits to userspace with KVM_EXIT_IO, KVM guarantees | |
| 1035 | + * guest state is consistent only after userspace re-enters the | |
| 1036 | + * kernel with KVM_RUN. Complete IO prior to migrating state | |
| 1037 | + * to a new VM. | |
| 1038 | + */ | |
| 1039 | + vcpu_run_complete_io(vm, vcpuid); | |
| 1040 | + | |
| 1033 | 1041 | nmsrs = kvm_get_num_msrs(vm); |
| 1034 | 1042 | list = malloc(sizeof(*list) + nmsrs * sizeof(list->indices[0])); |
| 1035 | 1043 | list->nmsrs = nmsrs; |
| @@ -1093,12 +1101,6 @@ void vcpu_load_state(struct kvm_vm *vm, uint32_t vcpuid, struct kvm_x86_state *s · 57 unmodified lines | ||
| 1093 | 1101 | struct vcpu *vcpu = vcpu_find(vm, vcpuid); |
| 1094 | 1102 | int r; |
| 1095 | 1103 | |
| 1096 | − if (state->nested.size) { | |
| 1097 | − r = ioctl(vcpu->fd, KVM_SET_NESTED_STATE, &state->nested); | |
| 1098 | − TEST_ASSERT(r == 0, "Unexpected result from KVM_SET_NESTED_STATE, r: %i", | |
| 1099 | − r); | |
| 1100 | − } | |
| 1101 | − | |
| 1102 | 1104 | r = ioctl(vcpu->fd, KVM_SET_XSAVE, &state->xsave); |
| 1103 | 1105 | TEST_ASSERT(r == 0, "Unexpected result from KVM_SET_XSAVE, r: %i", |
| 1104 | 1106 | r); |
| @@ -1130,4 +1132,10 @@ void vcpu_load_state(struct kvm_vm *vm, uint32_t vcpuid, struct kvm_x86_state *s · 25 unmodified lines | ||
| 1130 | 1132 | r = ioctl(vcpu->fd, KVM_SET_REGS, &state->regs); |
| 1131 | 1133 | TEST_ASSERT(r == 0, "Unexpected result from KVM_SET_REGS, r: %i", |
| 1132 | 1134 | r); |
| 1135 | + | |
| 1136 | + if (state->nested.size) { | |
| 1137 | + r = ioctl(vcpu->fd, KVM_SET_NESTED_STATE, &state->nested); | |
| 1138 | + TEST_ASSERT(r == 0, "Unexpected result from KVM_SET_NESTED_STATE, r: %i", | |
| 1139 | + r); | |
| 1140 | + } | |
| 1133 | 1141 | } |
| @@ -123,8 +123,6 @@ int main(int argc, char *argv[]) · 122 unmodified lines | ||
| 123 | 123 | stage, run->exit_reason, |
| 124 | 124 | exit_reason_str(run->exit_reason)); |
| 125 | 125 | |
| 126 | − memset(®s1, 0, sizeof(regs1)); | |
| 127 | − vcpu_regs_get(vm, VCPU_ID, ®s1); | |
| 128 | 126 | switch (get_ucall(vm, VCPU_ID, &uc)) { |
| 129 | 127 | case UCALL_ABORT: |
| 130 | 128 | TEST_ASSERT(false, "%s at %s:%d", (const char *)uc.args[0], |
| @@ -144,6 +142,9 @@ int main(int argc, char *argv[]) · 13 unmodified lines | ||
| 144 | 142 | stage, (ulong)uc.args[1]); |
| 145 | 143 | |
| 146 | 144 | state = vcpu_save_state(vm, VCPU_ID); |
| 145 | + memset(®s1, 0, sizeof(regs1)); | |
| 146 | + vcpu_regs_get(vm, VCPU_ID, ®s1); | |
| 147 | + | |
| 147 | 148 | kvm_vm_release(vm); |
| 148 | 149 | |
| 149 | 150 | /* Restore state in a new VM. */ |
| @@ -0,0 +1,157 @@ | ||
| 1 | +// SPDX-License-Identifier: GPL-2.0 | |
| 2 | +/* | |
| 3 | + * Copyright (C) 2018, Red Hat, Inc. | |
| 4 | + * | |
| 5 | + * Tests for SMM. | |
| 6 | + */ | |
| 7 | +#define _GNU_SOURCE /* for program_invocation_short_name */ | |
| 8 | +#include <fcntl.h> | |
| 9 | +#include <stdio.h> | |
| 10 | +#include <stdlib.h> | |
| 11 | +#include <stdint.h> | |
| 12 | +#include <string.h> | |
| 13 | +#include <sys/ioctl.h> | |
| 14 | + | |
| 15 | +#include "test_util.h" | |
| 16 | + | |
| 17 | +#include "kvm_util.h" | |
| 18 | + | |
| 19 | +#include "vmx.h" | |
| 20 | + | |
| 21 | +#define VCPU_ID 1 | |
| 22 | + | |
| 23 | +#define PAGE_SIZE 4096 | |
| 24 | + | |
| 25 | +#define SMRAM_SIZE 65536 | |
| 26 | +#define SMRAM_MEMSLOT ((1 << 16) | 1) | |
| 27 | +#define SMRAM_PAGES (SMRAM_SIZE / PAGE_SIZE) | |
| 28 | +#define SMRAM_GPA 0x1000000 | |
| 29 | +#define SMRAM_STAGE 0xfe | |
| 30 | + | |
| 31 | +#define STR(x) #x | |
| 32 | +#define XSTR(s) STR(s) | |
| 33 | + | |
| 34 | +#define SYNC_PORT 0xe | |
| 35 | +#define DONE 0xff | |
| 36 | + | |
| 37 | +/* | |
| 38 | + * This is compiled as normal 64-bit code, however, SMI handler is executed | |
| 39 | + * in real-address mode. To stay simple we're limiting ourselves to a mode | |
| 40 | + * independent subset of asm here. | |
| 41 | + * SMI handler always report back fixed stage SMRAM_STAGE. | |
| 42 | + */ | |
| 43 | +uint8_t smi_handler[] = { | |
| 44 | + 0xb0, SMRAM_STAGE, /* mov $SMRAM_STAGE, %al */ | |
| 45 | + 0xe4, SYNC_PORT, /* in $SYNC_PORT, %al */ | |
| 46 | + 0x0f, 0xaa, /* rsm */ | |
| 47 | +}; | |
| 48 | + | |
| 49 | +void sync_with_host(uint64_t phase) | |
| 50 | +{ | |
| 51 | + asm volatile("in $" XSTR(SYNC_PORT)", %%al \n" | |
| 52 | + : : "a" (phase)); | |
| 53 | +} | |
| 54 | + | |
| 55 | +void self_smi(void) | |
| 56 | +{ | |
| 57 | + wrmsr(APIC_BASE_MSR + (APIC_ICR >> 4), | |
| 58 | + APIC_DEST_SELF | APIC_INT_ASSERT | APIC_DM_SMI); | |
| 59 | +} | |
| 60 | + | |
| 61 | +void guest_code(struct vmx_pages *vmx_pages) | |
| 62 | +{ | |
| 63 | + uint64_t apicbase = rdmsr(MSR_IA32_APICBASE); | |
| 64 | + | |
| 65 | + sync_with_host(1); | |
| 66 | + | |
| 67 | + wrmsr(MSR_IA32_APICBASE, apicbase | X2APIC_ENABLE); | |
| 68 | + | |
| 69 | + sync_with_host(2); | |
| 70 | + | |
| 71 | + self_smi(); | |
| 72 | + | |
| 73 | + sync_with_host(4); | |
| 74 | + | |
| 75 | + if (vmx_pages) { | |
| 76 | + GUEST_ASSERT(prepare_for_vmx_operation(vmx_pages)); | |
| 77 | + | |
| 78 | + sync_with_host(5); | |
| 79 | + | |
| 80 | + self_smi(); | |
| 81 | + | |
| 82 | + sync_with_host(7); | |
| 83 | + } | |
| 84 | + | |
| 85 | + sync_with_host(DONE); | |
| 86 | +} | |
| 87 | + | |
| 88 | +int main(int argc, char *argv[]) | |
| 89 | +{ | |
| 90 | + struct vmx_pages *vmx_pages = NULL; | |
| 91 | + vm_vaddr_t vmx_pages_gva = 0; | |
| 92 | + | |
| 93 | + struct kvm_regs regs; | |
| 94 | + struct kvm_vm *vm; | |
| 95 | + struct kvm_run *run; | |
| 96 | + struct kvm_x86_state *state; | |
| 97 | + int stage, stage_reported; | |
| 98 | + | |
| 99 | + /* Create VM */ | |
| 100 | + vm = vm_create_default(VCPU_ID, 0, guest_code); | |
| 101 | + | |
| 102 | + vcpu_set_cpuid(vm, VCPU_ID, kvm_get_supported_cpuid()); | |
| 103 | + | |
| 104 | + run = vcpu_state(vm, VCPU_ID); | |
| 105 | + | |
| 106 | + vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS, SMRAM_GPA, | |
| 107 | + SMRAM_MEMSLOT, SMRAM_PAGES, 0); | |
| 108 | + TEST_ASSERT(vm_phy_pages_alloc(vm, SMRAM_PAGES, SMRAM_GPA, SMRAM_MEMSLOT) | |
| 109 | + == SMRAM_GPA, "could not allocate guest physical addresses?"); | |
| 110 | + | |
| 111 | + memset(addr_gpa2hva(vm, SMRAM_GPA), 0x0, SMRAM_SIZE); | |
| 112 | + memcpy(addr_gpa2hva(vm, SMRAM_GPA) + 0x8000, smi_handler, | |
| 113 | + sizeof(smi_handler)); | |
| 114 | + | |
| 115 | + vcpu_set_msr(vm, VCPU_ID, MSR_IA32_SMBASE, SMRAM_GPA); | |
| 116 | + | |
| 117 | + if (kvm_check_cap(KVM_CAP_NESTED_STATE)) { | |
| 118 | + vmx_pages = vcpu_alloc_vmx(vm, &vmx_pages_gva); | |
| 119 | + vcpu_args_set(vm, VCPU_ID, 1, vmx_pages_gva); | |
| 120 | + } else { | |
| 121 | + printf("will skip SMM test with VMX enabled\n"); | |
| 122 | + vcpu_args_set(vm, VCPU_ID, 1, 0); | |
| 123 | + } | |
| 124 | + | |
| 125 | + for (stage = 1;; stage++) { | |
| 126 | + _vcpu_run(vm, VCPU_ID); | |
| 127 | + TEST_ASSERT(run->exit_reason == KVM_EXIT_IO, | |
| 128 | + "Stage %d: unexpected exit reason: %u (%s),\n", | |
| 129 | + stage, run->exit_reason, | |
| 130 | + exit_reason_str(run->exit_reason)); | |
| 131 | + | |
| 132 | + memset(®s, 0, sizeof(regs)); | |
| 133 | + vcpu_regs_get(vm, VCPU_ID, ®s); | |
| 134 | + | |
| 135 | + stage_reported = regs.rax & 0xff; | |
| 136 | + | |
| 137 | + if (stage_reported == DONE) | |
| 138 | + goto done; | |
| 139 | + | |
| 140 | + TEST_ASSERT(stage_reported == stage || | |
| 141 | + stage_reported == SMRAM_STAGE, | |
| 142 | + "Unexpected stage: #%x, got %x", | |
| 143 | + stage, stage_reported); | |
| 144 | + | |
| 145 | + state = vcpu_save_state(vm, VCPU_ID); | |
| 146 | + kvm_vm_release(vm); | |
| 147 | + kvm_vm_restart(vm, O_RDWR); | |
| 148 | + vm_vcpu_add(vm, VCPU_ID, 0, 0); | |
| 149 | + vcpu_set_cpuid(vm, VCPU_ID, kvm_get_supported_cpuid()); | |
| 150 | + vcpu_load_state(vm, VCPU_ID, state); | |
| 151 | + run = vcpu_state(vm, VCPU_ID); | |
| 152 | + free(state); | |
| 153 | + } | |
| 154 | + | |
| 155 | +done: | |
| 156 | + kvm_vm_free(vm); | |
| 157 | +} | |
| @@ -134,11 +134,6 @@ int main(int argc, char *argv[]) · 133 unmodified lines | ||
| 134 | 134 | |
| 135 | 135 | struct kvm_cpuid_entry2 *entry = kvm_get_supported_cpuid_entry(1); |
| 136 | 136 | |
| 137 | − if (!kvm_check_cap(KVM_CAP_IMMEDIATE_EXIT)) { | |
| 138 | − fprintf(stderr, "immediate_exit not available, skipping test\n"); | |
| 139 | − exit(KSFT_SKIP); | |
| 140 | − } | |
| 141 | − | |
| 142 | 137 | /* Create VM */ |
| 143 | 138 | vm = vm_create_default(VCPU_ID, 0, guest_code); |
| 144 | 139 | vcpu_set_cpuid(vm, VCPU_ID, kvm_get_supported_cpuid()); |
| @@ -179,18 +174,10 @@ int main(int argc, char *argv[]) · 34 unmodified lines | ||
| 179 | 174 | uc.args[1] == stage, "Unexpected register values vmexit #%lx, got %lx", |
| 180 | 175 | stage, (ulong)uc.args[1]); |
| 181 | 176 | |
| 182 | − /* | |
| 183 | − * When KVM exits to userspace with KVM_EXIT_IO, KVM guarantees | |
| 184 | − * guest state is consistent only after userspace re-enters the | |
| 185 | − * kernel with KVM_RUN. Complete IO prior to migrating state | |
| 186 | − * to a new VM. | |
| 187 | − */ | |
| 188 | − vcpu_run_complete_io(vm, VCPU_ID); | |
| 189 | − | |
| 177 | + state = vcpu_save_state(vm, VCPU_ID); | |
| 190 | 178 | memset(®s1, 0, sizeof(regs1)); |
| 191 | 179 | vcpu_regs_get(vm, VCPU_ID, ®s1); |
| 192 | 180 | |
| 193 | − state = vcpu_save_state(vm, VCPU_ID); | |
| 194 | 181 | kvm_vm_release(vm); |
| 195 | 182 | |
| 196 | 183 | /* Restore state in a new VM. */ |
| @@ -607,6 +607,39 @@ run_cmd() · 606 unmodified lines | ||
| 607 | 607 | return $rc |
| 608 | 608 | } |
| 609 | 609 | |
| 610 | +check_expected() | |
| 611 | +{ | |
| 612 | + local out="$1" | |
| 613 | + local expected="$2" | |
| 614 | + local rc=0 | |
| 615 | + | |
| 616 | + [ "${out}" = "${expected}" ] && return 0 | |
| 617 | + | |
| 618 | + if [ -z "${out}" ]; then | |
| 619 | + if [ "$VERBOSE" = "1" ]; then | |
| 620 | + printf "\nNo route entry found\n" | |
| 621 | + printf "Expected:\n" | |
| 622 | + printf " ${expected}\n" | |
| 623 | + fi | |
| 624 | + return 1 | |
| 625 | + fi | |
| 626 | + | |
| 627 | + # tricky way to convert output to 1-line without ip's | |
| 628 | + # messy '\'; this drops all extra white space | |
| 629 | + out=$(echo ${out}) | |
| 630 | + if [ "${out}" != "${expected}" ]; then | |
| 631 | + rc=1 | |
| 632 | + if [ "${VERBOSE}" = "1" ]; then | |
| 633 | + printf " Unexpected route entry. Have:\n" | |
| 634 | + printf " ${out}\n" | |
| 635 | + printf " Expected:\n" | |
| 636 | + printf " ${expected}\n\n" | |
| 637 | + fi | |
| 638 | + fi | |
| 639 | + | |
| 640 | + return $rc | |
| 641 | +} | |
| 642 | + | |
| 610 | 643 | # add route for a prefix, flushing any existing routes first |
| 611 | 644 | # expected to be the first step of a test |
| 612 | 645 | add_route6() |
| @@ -654,31 +687,7 @@ check_route6() · 41 unmodified lines | ||
| 654 | 687 | pfx=$1 |
| 655 | 688 | |
| 656 | 689 | out=$($IP -6 ro ls match ${pfx} | sed -e 's/ pref medium//') |
| 657 | − [ "${out}" = "${expected}" ] && return 0 | |
| 658 | − | |
| 659 | − if [ -z "${out}" ]; then | |
| 660 | − if [ "$VERBOSE" = "1" ]; then | |
| 661 | − printf "\nNo route entry found\n" | |
| 662 | − printf "Expected:\n" | |
| 663 | − printf " ${expected}\n" | |
| 664 | − fi | |
| 665 | − return 1 | |
| 666 | − fi | |
| 667 | − | |
| 668 | − # tricky way to convert output to 1-line without ip's | |
| 669 | − # messy '\'; this drops all extra white space | |
| 670 | − out=$(echo ${out}) | |
| 671 | − if [ "${out}" != "${expected}" ]; then | |
| 672 | − rc=1 | |
| 673 | − if [ "${VERBOSE}" = "1" ]; then | |
| 674 | − printf " Unexpected route entry. Have:\n" | |
| 675 | − printf " ${out}\n" | |
| 676 | − printf " Expected:\n" | |
| 677 | − printf " ${expected}\n\n" | |
| 678 | − fi | |
| 679 | − fi | |
| 680 | − | |
| 681 | − return $rc | |
| 690 | + check_expected "${out}" "${expected}" | |
| 682 | 691 | } |
| 683 | 692 | |
| 684 | 693 | route_cleanup() |
| @@ -728,7 +737,7 @@ route_setup() · 43 unmodified lines | ||
| 728 | 737 | ip -netns ns2 addr add 172.16.103.2/24 dev veth4 |
| 729 | 738 | ip -netns ns2 addr add 172.16.104.1/24 dev dummy1 |
| 730 | 739 | |
| 731 | − set +ex | |
| 740 | + set +e | |
| 732 | 741 | } |
| 733 | 742 | |
| 734 | 743 | # assumption is that basic add of a single path route works |
| @@ -963,7 +972,8 @@ ipv6_addr_metric_test() · 228 unmodified lines | ||
| 963 | 972 | run_cmd "$IP li set dev dummy2 down" |
| 964 | 973 | rc=$? |
| 965 | 974 | if [ $rc -eq 0 ]; then |
| 966 | − check_route6 "" | |
| 975 | + out=$($IP -6 ro ls match 2001:db8:104::/64) | |
| 976 | + check_expected "${out}" "" | |
| 967 | 977 | rc=$? |
| 968 | 978 | fi |
| 969 | 979 | log_test $rc 0 "Prefix route removed on link down" |
| @@ -1094,38 +1104,13 @@ check_route() · 124 unmodified lines | ||
| 1094 | 1104 | local pfx |
| 1095 | 1105 | local expected="$1" |
| 1096 | 1106 | local out |
| 1097 | − local rc=0 | |
| 1098 | 1107 | |
| 1099 | 1108 | set -- $expected |
| 1100 | 1109 | pfx=$1 |
| 1101 | 1110 | [ "${pfx}" = "unreachable" ] && pfx=$2 |
| 1102 | 1111 | |
| 1103 | 1112 | out=$($IP ro ls match ${pfx}) |
| 1104 | − [ "${out}" = "${expected}" ] && return 0 | |
| 1105 | − | |
| 1106 | − if [ -z "${out}" ]; then | |
| 1107 | − if [ "$VERBOSE" = "1" ]; then | |
| 1108 | − printf "\nNo route entry found\n" | |
| 1109 | − printf "Expected:\n" | |
| 1110 | − printf " ${expected}\n" | |
| 1111 | − fi | |
| 1112 | − return 1 | |
| 1113 | − fi | |
| 1114 | − | |
| 1115 | − # tricky way to convert output to 1-line without ip's | |
| 1116 | − # messy '\'; this drops all extra white space | |
| 1117 | − out=$(echo ${out}) | |
| 1118 | − if [ "${out}" != "${expected}" ]; then | |
| 1119 | − rc=1 | |
| 1120 | − if [ "${VERBOSE}" = "1" ]; then | |
| 1121 | − printf " Unexpected route entry. Have:\n" | |
| 1122 | − printf " ${out}\n" | |
| 1123 | − printf " Expected:\n" | |
| 1124 | − printf " ${expected}\n\n" | |
| 1125 | − fi | |
| 1126 | − fi | |
| 1127 | − | |
| 1128 | − return $rc | |
| 1113 | + check_expected "${out}" "${expected}" | |
| 1129 | 1114 | } |
| 1130 | 1115 | |
| 1131 | 1116 | # assumption is that basic add of a single path route works |
| @@ -1390,7 +1375,8 @@ ipv4_addr_metric_test() · 258 unmodified lines | ||
| 1390 | 1375 | run_cmd "$IP li set dev dummy2 down" |
| 1391 | 1376 | rc=$? |
| 1392 | 1377 | if [ $rc -eq 0 ]; then |
| 1393 | − check_route "" | |
| 1378 | + out=$($IP ro ls match 172.16.104.0/24) | |
| 1379 | + check_expected "${out}" "" | |
| 1394 | 1380 | rc=$? |
| 1395 | 1381 | fi |
| 1396 | 1382 | log_test $rc 0 "Prefix route removed on link down" |
| @@ -144,18 +144,19 @@ static int setup_routing_entry(struct kvm *kvm, · 143 unmodified lines | ||
| 144 | 144 | { |
| 145 | 145 | struct kvm_kernel_irq_routing_entry *ei; |
| 146 | 146 | int r; |
| 147 | + u32 gsi = array_index_nospec(ue->gsi, KVM_MAX_IRQ_ROUTES); | |
| 147 | 148 | |
| 148 | 149 | /* |
| 149 | 150 | * Do not allow GSI to be mapped to the same irqchip more than once. |
| 150 | 151 | * Allow only one to one mapping between GSI and non-irqchip routing. |
| 151 | 152 | */ |
| 152 | − hlist_for_each_entry(ei, &rt->map[ue->gsi], link) | |
| 153 | + hlist_for_each_entry(ei, &rt->map[gsi], link) | |
| 153 | 154 | if (ei->type != KVM_IRQ_ROUTING_IRQCHIP || |
| 154 | 155 | ue->type != KVM_IRQ_ROUTING_IRQCHIP || |
| 155 | 156 | ue->u.irqchip.irqchip == ei->irqchip.irqchip) |
| 156 | 157 | return -EINVAL; |
| 157 | 158 | |
| 158 | − e->gsi = ue->gsi; | |
| 159 | + e->gsi = gsi; | |
| 159 | 160 | e->type = ue->type; |
| 160 | 161 | r = kvm_set_routing_entry(kvm, e, ue); |
| 161 | 162 | if (r) |
| @@ -2977,12 +2977,14 @@ static int kvm_ioctl_create_device(struct kvm *kvm, · 2976 unmodified lines | ||
| 2977 | 2977 | struct kvm_device_ops *ops = NULL; |
| 2978 | 2978 | struct kvm_device *dev; |
| 2979 | 2979 | bool test = cd->flags & KVM_CREATE_DEVICE_TEST; |
| 2980 | + int type; | |
| 2980 | 2981 | int ret; |
| 2981 | 2982 | |
| 2982 | 2983 | if (cd->type >= ARRAY_SIZE(kvm_device_ops_table)) |
| 2983 | 2984 | return -ENODEV; |
| 2984 | 2985 | |
| 2985 | − ops = kvm_device_ops_table[cd->type]; | |
| 2986 | + type = array_index_nospec(cd->type, ARRAY_SIZE(kvm_device_ops_table)); | |
| 2987 | + ops = kvm_device_ops_table[type]; | |
| 2986 | 2988 | if (ops == NULL) |
| 2987 | 2989 | return -ENODEV; |
| 2988 | 2990 | |
| @@ -2997,7 +2999,7 @@ static int kvm_ioctl_create_device(struct kvm *kvm, · 8 unmodified lines | ||
| 2997 | 2999 | dev->kvm = kvm; |
| 2998 | 3000 | |
| 2999 | 3001 | mutex_lock(&kvm->lock); |
| 3000 | − ret = ops->create(dev, cd->type); | |
| 3002 | + ret = ops->create(dev, type); | |
| 3001 | 3003 | if (ret < 0) { |
| 3002 | 3004 | mutex_unlock(&kvm->lock); |
| 3003 | 3005 | kfree(dev); |