From 5b7c4cabbb65f5c469464da6c5f614cbd7f730f2 Mon Sep 17 00:00:00 2001 From: Linus Torvalds Date: Tue, 21 Feb 2023 18:24:12 -0800 Subject: Merge tag 'net-next-6.3' of git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next Pull networking updates from Jakub Kicinski: "Core: - Add dedicated kmem_cache for typical/small skb->head, avoid having to access struct page at kfree time, and improve memory use. - Introduce sysctl to set default RPS configuration for new netdevs. - Define Netlink protocol specification format which can be used to describe messages used by each family and auto-generate parsers. Add tools for generating kernel data structures and uAPI headers. - Expose all net/core sysctls inside netns. - Remove 4s sleep in netpoll if carrier is instantly detected on boot. - Add configurable limit of MDB entries per port, and port-vlan. - Continue populating drop reasons throughout the stack. - Retire a handful of legacy Qdiscs and classifiers. Protocols: - Support IPv4 big TCP (TSO frames larger than 64kB). - Add IP_LOCAL_PORT_RANGE socket option, to control local port range on socket by socket basis. - Track and report in procfs number of MPTCP sockets used. - Support mixing IPv4 and IPv6 flows in the in-kernel MPTCP path manager. - IPv6: don't check net.ipv6.route.max_size and rely on garbage collection to free memory (similarly to IPv4). - Support Penultimate Segment Pop (PSP) flavor in SRv6 (RFC8986). - ICMP: add per-rate limit counters. - Add support for user scanning requests in ieee802154. - Remove static WEP support. - Support minimal Wi-Fi 7 Extremely High Throughput (EHT) rate reporting. - WiFi 7 EHT channel puncturing support (client & AP). BPF: - Add a rbtree data structure following the "next-gen data structure" precedent set by recently added linked list, that is, by using kfunc + kptr instead of adding a new BPF map type. - Expose XDP hints via kfuncs with initial support for RX hash and timestamp metadata. - Add BPF_F_NO_TUNNEL_KEY extension to bpf_skb_set_tunnel_key to better support decap on GRE tunnel devices not operating in collect metadata. - Improve x86 JIT's codegen for PROBE_MEM runtime error checks. - Remove the need for trace_printk_lock for bpf_trace_printk and bpf_trace_vprintk helpers. - Extend libbpf's bpf_tracing.h support for tracing arguments of kprobes/uprobes and syscall as a special case. - Significantly reduce the search time for module symbols by livepatch and BPF. - Enable cpumasks to be used as kptrs, which is useful for tracing programs tracking which tasks end up running on which CPUs in different time intervals. - Add support for BPF trampoline on s390x and riscv64. - Add capability to export the XDP features supported by the NIC. - Add __bpf_kfunc tag for marking kernel functions as kfuncs. - Add cgroup.memory=nobpf kernel parameter option to disable BPF memory accounting for container environments. Netfilter: - Remove the CLUSTERIP target. It has been marked as obsolete for years, and we still have WARN splats wrt races of the out-of-band /proc interface installed by this target. - Add 'destroy' commands to nf_tables. They are identical to the existing 'delete' commands, but do not return an error if the referenced object (set, chain, rule...) did not exist. Driver API: - Improve cpumask_local_spread() locality to help NICs set the right IRQ affinity on AMD platforms. - Separate C22 and C45 MDIO bus transactions more clearly. - Introduce new DCB table to control DSCP rewrite on egress. - Support configuration of Physical Layer Collision Avoidance (PLCA) Reconciliation Sublayer (RS) (802.3cg-2019). Modern version of shared medium Ethernet. - Support for MAC Merge layer (IEEE 802.3-2018 clause 99). Allowing preemption of low priority frames by high priority frames. - Add support for controlling MACSec offload using netlink SET. - Rework devlink instance refcounts to allow registration and de-registration under the instance lock. Split the code into multiple files, drop some of the unnecessarily granular locks and factor out common parts of netlink operation handling. - Add TX frame aggregation parameters (for USB drivers). - Add a new attr TCA_EXT_WARN_MSG to report TC (offload) warning messages with notifications for debug. - Allow offloading of UDP NEW connections via act_ct. - Add support for per action HW stats in TC. - Support hardware miss to TC action (continue processing in SW from a specific point in the action chain). - Warn if old Wireless Extension user space interface is used with modern cfg80211/mac80211 drivers. Do not support Wireless Extensions for Wi-Fi 7 devices at all. Everyone should switch to using nl80211 interface instead. - Improve the CAN bit timing configuration. Use extack to return error messages directly to user space, update the SJW handling, including the definition of a new default value that will benefit CAN-FD controllers, by increasing their oscillator tolerance. New hardware / drivers: - Ethernet: - nVidia BlueField-3 support (control traffic driver) - Ethernet support for imx93 SoCs - Motorcomm yt8531 gigabit Ethernet PHY - onsemi NCN26000 10BASE-T1S PHY (with support for PLCA) - Microchip LAN8841 PHY (incl. cable diagnostics and PTP) - Amlogic gxl MDIO mux - WiFi: - RealTek RTL8188EU (rtl8xxxu) - Qualcomm Wi-Fi 7 devices (ath12k) - CAN: - Renesas R-Car V4H Drivers: - Bluetooth: - Set Per Platform Antenna Gain (PPAG) for Intel controllers. - Ethernet NICs: - Intel (1G, igc): - support TSN / Qbv / packet scheduling features of i226 model - Intel (100G, ice): - use GNSS subsystem instead of TTY - multi-buffer XDP support - extend support for GPIO pins to E823 devices - nVidia/Mellanox: - update the shared buffer configuration on PFC commands - implement PTP adjphase function for HW offset control - TC support for Geneve and GRE with VF tunnel offload - more efficient crypto key management method - multi-port eswitch support - Netronome/Corigine: - add DCB IEEE support - support IPsec offloading for NFP3800 - Freescale/NXP (enetc): - support XDP_REDIRECT for XDP non-linear buffers - improve reconfig, avoid link flap and waiting for idle - support MAC Merge layer - Other NICs: - sfc/ef100: add basic devlink support for ef100 - ionic: rx_push mode operation (writing descriptors via MMIO) - bnxt: use the auxiliary bus abstraction for RDMA - r8169: disable ASPM and reset bus in case of tx timeout - cpsw: support QSGMII mode for J721e CPSW9G - cpts: support pulse-per-second output - ngbe: add an mdio bus driver - usbnet: optimize usbnet_bh() by avoiding unnecessary queuing - r8152: handle devices with FW with NCM support - amd-xgbe: support 10Mbps, 2.5GbE speeds and rx-adaptation - virtio-net: support multi buffer XDP - virtio/vsock: replace virtio_vsock_pkt with sk_buff - tsnep: XDP support - Ethernet high-speed switches: - nVidia/Mellanox (mlxsw): - add support for latency TLV (in FW control messages) - Microchip (sparx5): - separate explicit and implicit traffic forwarding rules, make the implicit rules always active - add support for egress DSCP rewrite - IS0 VCAP support (Ingress Classification) - IS2 VCAP filters (protos, L3 addrs, L4 ports, flags, ToS etc.) - ES2 VCAP support (Egress Access Control) - support for Per-Stream Filtering and Policing (802.1Q, 8.6.5.1) - Ethernet embedded switches: - Marvell (mv88e6xxx): - add MAB (port auth) offload support - enable PTP receive for mv88e6390 - NXP (ocelot): - support MAC Merge layer - support for the the vsc7512 internal copper phys - Microchip: - lan9303: convert to PHYLINK - lan966x: support TC flower filter statistics - lan937x: PTP support for KSZ9563/KSZ8563 and LAN937x - lan937x: support Credit Based Shaper configuration - ksz9477: support Energy Efficient Ethernet - other: - qca8k: convert to regmap read/write API, use bulk operations - rswitch: Improve TX timestamp accuracy - Intel WiFi (iwlwifi): - EHT (Wi-Fi 7) rate reporting - STEP equalizer support: transfer some STEP (connection to radio on platforms with integrated wifi) related parameters from the BIOS to the firmware. - Qualcomm 802.11ax WiFi (ath11k): - IPQ5018 support - Fine Timing Measurement (FTM) responder role support - channel 177 support - MediaTek WiFi (mt76): - per-PHY LED support - mt7996: EHT (Wi-Fi 7) support - Wireless Ethernet Dispatch (WED) reset support - switch to using page pool allocator - RealTek WiFi (rtw89): - support new version of Bluetooth co-existance - Mobile: - rmnet: support TX aggregation" * tag 'net-next-6.3' of git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next: (1872 commits) page_pool: add a comment explaining the fragment counter usage net: ethtool: fix __ethtool_dev_mm_supported() implementation ethtool: pse-pd: Fix double word in comments xsk: add linux/vmalloc.h to xsk.c sefltests: netdevsim: wait for devlink instance after netns removal selftest: fib_tests: Always cleanup before exit net/mlx5e: Align IPsec ASO result memory to be as required by hardware net/mlx5e: TC, Set CT miss to the specific ct action instance net/mlx5e: Rename CHAIN_TO_REG to MAPPED_OBJ_TO_REG net/mlx5: Refactor tc miss handling to a single function net/mlx5: Kconfig: Make tc offload depend on tc skb extension net/sched: flower: Support hardware miss to tc action net/sched: flower: Move filter handle initialization earlier net/sched: cls_api: Support hardware miss to tc action net/sched: Rename user cookie and act cookie sfc: fix builds without CONFIG_RTC_LIB sfc: clean up some inconsistent indentings net/mlx4_en: Introduce flexible array to silence overflow warning net: lan966x: Fix possible deadlock inside PTP net/ulp: Remove redundant ->clone() test in inet_clone_ulp(). ... --- drivers/video/fbdev/valkyriefb.c | 578 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 578 insertions(+) create mode 100644 drivers/video/fbdev/valkyriefb.c (limited to 'drivers/video/fbdev/valkyriefb.c') diff --git a/drivers/video/fbdev/valkyriefb.c b/drivers/video/fbdev/valkyriefb.c new file mode 100644 index 000000000..1007023a5 --- /dev/null +++ b/drivers/video/fbdev/valkyriefb.c @@ -0,0 +1,578 @@ +/* + * valkyriefb.c -- frame buffer device for the PowerMac 'valkyrie' display + * + * Created 8 August 1998 by + * Martin Costabel and Kevin Schoedel + * + * Vmode-switching changes and vmode 15/17 modifications created 29 August + * 1998 by Barry K. Nathan . + * + * Ported to m68k Macintosh by David Huggins-Daines + * + * Derived directly from: + * + * controlfb.c -- frame buffer device for the PowerMac 'control' display + * Copyright (C) 1998 Dan Jacobowitz + * + * pmc-valkyrie.c -- Console support for PowerMac "valkyrie" display adaptor. + * Copyright (C) 1997 Paul Mackerras. + * + * and indirectly: + * + * Frame buffer structure from: + * drivers/video/chipsfb.c -- frame buffer device for + * Chips & Technologies 65550 chip. + * + * Copyright (C) 1998 Paul Mackerras + * + * This file is derived from the Powermac "chips" driver: + * Copyright (C) 1997 Fabio Riccardi. + * And from the frame buffer device for Open Firmware-initialized devices: + * Copyright (C) 1997 Geert Uytterhoeven. + * + * Hardware information from: + * control.c: Console support for PowerMac "control" display adaptor. + * Copyright (C) 1996 Paul Mackerras + * + * This file is subject to the terms and conditions of the GNU General Public + * License. See the file COPYING in the main directory of this archive for + * more details. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifdef CONFIG_MAC +#include +#endif + +#include "macmodes.h" +#include "valkyriefb.h" + +static int default_vmode = VMODE_NVRAM; +static int default_cmode = CMODE_NVRAM; + +struct fb_par_valkyrie { + int vmode, cmode; + int xres, yres; + int vxres, vyres; + struct valkyrie_regvals *init; +}; + +struct fb_info_valkyrie { + struct fb_info info; + struct fb_par_valkyrie par; + struct cmap_regs __iomem *cmap_regs; + unsigned long cmap_regs_phys; + + struct valkyrie_regs __iomem *valkyrie_regs; + unsigned long valkyrie_regs_phys; + + __u8 __iomem *frame_buffer; + unsigned long frame_buffer_phys; + + int sense; + unsigned long total_vram; + + u32 pseudo_palette[16]; +}; + +static int valkyriefb_setup(char*); + +static int valkyriefb_check_var(struct fb_var_screeninfo *var, + struct fb_info *info); +static int valkyriefb_set_par(struct fb_info *info); +static int valkyriefb_setcolreg(u_int regno, u_int red, u_int green, u_int blue, + u_int transp, struct fb_info *info); +static int valkyriefb_blank(int blank_mode, struct fb_info *info); + +static int read_valkyrie_sense(struct fb_info_valkyrie *p); +static void set_valkyrie_clock(unsigned char *params); +static int valkyrie_var_to_par(struct fb_var_screeninfo *var, + struct fb_par_valkyrie *par, const struct fb_info *fb_info); + +static int valkyrie_init_info(struct fb_info *info, struct fb_info_valkyrie *p); +static void valkyrie_par_to_fix(struct fb_par_valkyrie *par, struct fb_fix_screeninfo *fix); +static void valkyrie_init_fix(struct fb_fix_screeninfo *fix, struct fb_info_valkyrie *p); + +static const struct fb_ops valkyriefb_ops = { + .owner = THIS_MODULE, + .fb_check_var = valkyriefb_check_var, + .fb_set_par = valkyriefb_set_par, + .fb_setcolreg = valkyriefb_setcolreg, + .fb_blank = valkyriefb_blank, + .fb_fillrect = cfb_fillrect, + .fb_copyarea = cfb_copyarea, + .fb_imageblit = cfb_imageblit, +}; + +/* Sets the video mode according to info->var */ +static int valkyriefb_set_par(struct fb_info *info) +{ + struct fb_info_valkyrie *p = + container_of(info, struct fb_info_valkyrie, info); + volatile struct valkyrie_regs __iomem *valkyrie_regs = p->valkyrie_regs; + struct fb_par_valkyrie *par = info->par; + struct valkyrie_regvals *init; + int err; + + if ((err = valkyrie_var_to_par(&info->var, par, info))) + return err; + + valkyrie_par_to_fix(par, &info->fix); + + /* Reset the valkyrie */ + out_8(&valkyrie_regs->status.r, 0); + udelay(100); + + /* Initialize display timing registers */ + init = par->init; + out_8(&valkyrie_regs->mode.r, init->mode | 0x80); + out_8(&valkyrie_regs->depth.r, par->cmode + 3); + set_valkyrie_clock(init->clock_params); + udelay(100); + + /* Turn on display */ + out_8(&valkyrie_regs->mode.r, init->mode); + + return 0; +} + +static inline int valkyrie_par_to_var(struct fb_par_valkyrie *par, + struct fb_var_screeninfo *var) +{ + return mac_vmode_to_var(par->vmode, par->cmode, var); +} + +static int +valkyriefb_check_var(struct fb_var_screeninfo *var, struct fb_info *info) +{ + int err; + struct fb_par_valkyrie par; + + if ((err = valkyrie_var_to_par(var, &par, info))) + return err; + valkyrie_par_to_var(&par, var); + return 0; +} + +/* + * Blank the screen if blank_mode != 0, else unblank. If blank_mode == NULL + * then the caller blanks by setting the CLUT (Color Look Up Table) to all + * black. Return 0 if blanking succeeded, != 0 if un-/blanking failed due + * to e.g. a video mode which doesn't support it. Implements VESA suspend + * and powerdown modes on hardware that supports disabling hsync/vsync: + * blank_mode == 2: suspend vsync + * blank_mode == 3: suspend hsync + * blank_mode == 4: powerdown + */ +static int valkyriefb_blank(int blank_mode, struct fb_info *info) +{ + struct fb_info_valkyrie *p = + container_of(info, struct fb_info_valkyrie, info); + struct fb_par_valkyrie *par = info->par; + struct valkyrie_regvals *init = par->init; + + if (init == NULL) + return 1; + + switch (blank_mode) { + case FB_BLANK_UNBLANK: /* unblank */ + out_8(&p->valkyrie_regs->mode.r, init->mode); + break; + case FB_BLANK_NORMAL: + return 1; /* get caller to set CLUT to all black */ + case FB_BLANK_VSYNC_SUSPEND: + case FB_BLANK_HSYNC_SUSPEND: + /* + * [kps] Value extracted from MacOS. I don't know + * whether this bit disables hsync or vsync, or + * whether the hardware can do the other as well. + */ + out_8(&p->valkyrie_regs->mode.r, init->mode | 0x40); + break; + case FB_BLANK_POWERDOWN: + out_8(&p->valkyrie_regs->mode.r, 0x66); + break; + } + return 0; +} + +static int valkyriefb_setcolreg(u_int regno, u_int red, u_int green, u_int blue, + u_int transp, struct fb_info *info) +{ + struct fb_info_valkyrie *p = + container_of(info, struct fb_info_valkyrie, info); + volatile struct cmap_regs __iomem *cmap_regs = p->cmap_regs; + struct fb_par_valkyrie *par = info->par; + + if (regno > 255) + return 1; + red >>= 8; + green >>= 8; + blue >>= 8; + + /* tell clut which address to fill */ + out_8(&p->cmap_regs->addr, regno); + udelay(1); + /* send one color channel at a time */ + out_8(&cmap_regs->lut, red); + out_8(&cmap_regs->lut, green); + out_8(&cmap_regs->lut, blue); + + if (regno < 16 && par->cmode == CMODE_16) + ((u32 *)info->pseudo_palette)[regno] = + (regno << 10) | (regno << 5) | regno; + + return 0; +} + +static inline int valkyrie_vram_reqd(int video_mode, int color_mode) +{ + int pitch; + struct valkyrie_regvals *init = valkyrie_reg_init[video_mode-1]; + + if ((pitch = init->pitch[color_mode]) == 0) + pitch = 2 * init->pitch[0]; + return init->vres * pitch; +} + +static void set_valkyrie_clock(unsigned char *params) +{ +#ifdef CONFIG_ADB_CUDA + struct adb_request req; + int i; + + for (i = 0; i < 3; ++i) { + cuda_request(&req, NULL, 5, CUDA_PACKET, CUDA_GET_SET_IIC, + 0x50, i + 1, params[i]); + while (!req.complete) + cuda_poll(); + } +#endif +} + +static void __init valkyrie_choose_mode(struct fb_info_valkyrie *p) +{ + p->sense = read_valkyrie_sense(p); + printk(KERN_INFO "Monitor sense value = 0x%x\n", p->sense); + + /* Try to pick a video mode out of NVRAM if we have one. */ +#ifdef CONFIG_PPC_PMAC + if (IS_REACHABLE(CONFIG_NVRAM) && default_vmode == VMODE_NVRAM) + default_vmode = nvram_read_byte(NV_VMODE); +#endif + if (default_vmode <= 0 || default_vmode > VMODE_MAX || + !valkyrie_reg_init[default_vmode - 1]) { + default_vmode = mac_map_monitor_sense(p->sense); + if (!valkyrie_reg_init[default_vmode - 1]) + default_vmode = VMODE_640_480_67; + } + +#ifdef CONFIG_PPC_PMAC + if (IS_REACHABLE(CONFIG_NVRAM) && default_cmode == CMODE_NVRAM) + default_cmode = nvram_read_byte(NV_CMODE); +#endif + /* + * Reduce the pixel size if we don't have enough VRAM or bandwidth. + */ + if (default_cmode < CMODE_8 || default_cmode > CMODE_16 + || valkyrie_reg_init[default_vmode-1]->pitch[default_cmode] == 0 + || valkyrie_vram_reqd(default_vmode, default_cmode) > p->total_vram) + default_cmode = CMODE_8; + + printk(KERN_INFO "using video mode %d and color mode %d.\n", + default_vmode, default_cmode); +} + +static int __init valkyriefb_init(void) +{ + struct fb_info_valkyrie *p; + unsigned long frame_buffer_phys, cmap_regs_phys; + int err; + char *option = NULL; + + if (fb_get_options("valkyriefb", &option)) + return -ENODEV; + valkyriefb_setup(option); + +#ifdef CONFIG_MAC + if (!MACH_IS_MAC) + return -ENODEV; + if (!(mac_bi_data.id == MAC_MODEL_Q630 + /* I'm not sure about this one */ + || mac_bi_data.id == MAC_MODEL_P588)) + return -ENODEV; + + /* Hardcoded addresses... welcome to 68k Macintosh country :-) */ + frame_buffer_phys = 0xf9000000; + cmap_regs_phys = 0x50f24000; +#else /* ppc (!CONFIG_MAC) */ + { + struct device_node *dp; + struct resource r; + + dp = of_find_node_by_name(NULL, "valkyrie"); + if (!dp) + return 0; + + if (of_address_to_resource(dp, 0, &r)) { + printk(KERN_ERR "can't find address for valkyrie\n"); + return 0; + } + + frame_buffer_phys = r.start; + cmap_regs_phys = r.start + 0x304000; + } +#endif /* ppc (!CONFIG_MAC) */ + + p = kzalloc(sizeof(*p), GFP_ATOMIC); + if (!p) + return -ENOMEM; + + /* Map in frame buffer and registers */ + if (!request_mem_region(frame_buffer_phys, 0x100000, "valkyriefb")) { + kfree(p); + return 0; + } + p->total_vram = 0x100000; + p->frame_buffer_phys = frame_buffer_phys; +#ifdef CONFIG_MAC + p->frame_buffer = ioremap(frame_buffer_phys, p->total_vram); +#else + p->frame_buffer = ioremap_wt(frame_buffer_phys, p->total_vram); +#endif + p->cmap_regs_phys = cmap_regs_phys; + p->cmap_regs = ioremap(p->cmap_regs_phys, 0x1000); + p->valkyrie_regs_phys = cmap_regs_phys+0x6000; + p->valkyrie_regs = ioremap(p->valkyrie_regs_phys, 0x1000); + err = -ENOMEM; + if (p->frame_buffer == NULL || p->cmap_regs == NULL + || p->valkyrie_regs == NULL) { + printk(KERN_ERR "valkyriefb: couldn't map resources\n"); + goto out_free; + } + + valkyrie_choose_mode(p); + mac_vmode_to_var(default_vmode, default_cmode, &p->info.var); + err = valkyrie_init_info(&p->info, p); + if (err < 0) + goto out_free; + valkyrie_init_fix(&p->info.fix, p); + if (valkyriefb_set_par(&p->info)) + /* "can't happen" */ + printk(KERN_ERR "valkyriefb: can't set default video mode\n"); + + if ((err = register_framebuffer(&p->info)) != 0) + goto out_cmap_free; + + fb_info(&p->info, "valkyrie frame buffer device\n"); + return 0; + + out_cmap_free: + fb_dealloc_cmap(&p->info.cmap); + out_free: + if (p->frame_buffer) + iounmap(p->frame_buffer); + if (p->cmap_regs) + iounmap(p->cmap_regs); + if (p->valkyrie_regs) + iounmap(p->valkyrie_regs); + kfree(p); + return err; +} + +/* + * Get the monitor sense value. + */ +static int read_valkyrie_sense(struct fb_info_valkyrie *p) +{ + int sense, in; + + out_8(&p->valkyrie_regs->msense.r, 0); /* release all lines */ + __delay(20000); + sense = ((in = in_8(&p->valkyrie_regs->msense.r)) & 0x70) << 4; + /* drive each sense line low in turn and collect the other 2 */ + out_8(&p->valkyrie_regs->msense.r, 4); /* drive A low */ + __delay(20000); + sense |= ((in = in_8(&p->valkyrie_regs->msense.r)) & 0x30); + out_8(&p->valkyrie_regs->msense.r, 2); /* drive B low */ + __delay(20000); + sense |= ((in = in_8(&p->valkyrie_regs->msense.r)) & 0x40) >> 3; + sense |= (in & 0x10) >> 2; + out_8(&p->valkyrie_regs->msense.r, 1); /* drive C low */ + __delay(20000); + sense |= ((in = in_8(&p->valkyrie_regs->msense.r)) & 0x60) >> 5; + + out_8(&p->valkyrie_regs->msense.r, 7); + + return sense; +} + +/* + * This routine takes a user-supplied var, + * and picks the best vmode/cmode from it. + */ + +/* [bkn] I did a major overhaul of this function. + * + * Much of the old code was "swiped by jonh from atyfb.c". Because + * macmodes has mac_var_to_vmode, I felt that it would be better to + * rework this function to use that, instead of reinventing the wheel to + * add support for vmode 17. This was reinforced by the fact that + * the previously swiped atyfb.c code is no longer there. + * + * So, I swiped and adapted platinum_var_to_par (from platinumfb.c), replacing + * most, but not all, of the old code in the process. One side benefit of + * swiping the platinumfb code is that we now have more comprehensible error + * messages when a vmode/cmode switch fails. (Most of the error messages are + * platinumfb.c, but I added two of my own, and I also changed some commas + * into colons to make the messages more consistent with other Linux error + * messages.) In addition, I think the new code *might* fix some vmode- + * switching oddities, but I'm not sure. + * + * There may be some more opportunities for cleanup in here, but this is a + * good start... + */ + +static int valkyrie_var_to_par(struct fb_var_screeninfo *var, + struct fb_par_valkyrie *par, const struct fb_info *fb_info) +{ + int vmode, cmode; + struct valkyrie_regvals *init; + struct fb_info_valkyrie *p = + container_of(fb_info, struct fb_info_valkyrie, info); + + if (mac_var_to_vmode(var, &vmode, &cmode) != 0) { + printk(KERN_ERR "valkyriefb: can't do %dx%dx%d.\n", + var->xres, var->yres, var->bits_per_pixel); + return -EINVAL; + } + + /* Check if we know about the wanted video mode */ + if (vmode < 1 || vmode > VMODE_MAX || !valkyrie_reg_init[vmode-1]) { + printk(KERN_ERR "valkyriefb: vmode %d not valid.\n", vmode); + return -EINVAL; + } + + if (cmode != CMODE_8 && cmode != CMODE_16) { + printk(KERN_ERR "valkyriefb: cmode %d not valid.\n", cmode); + return -EINVAL; + } + + if (var->xres_virtual > var->xres || var->yres_virtual > var->yres + || var->xoffset != 0 || var->yoffset != 0) { + return -EINVAL; + } + + init = valkyrie_reg_init[vmode-1]; + if (init->pitch[cmode] == 0) { + printk(KERN_ERR "valkyriefb: vmode %d does not support " + "cmode %d.\n", vmode, cmode); + return -EINVAL; + } + + if (valkyrie_vram_reqd(vmode, cmode) > p->total_vram) { + printk(KERN_ERR "valkyriefb: not enough ram for vmode %d, " + "cmode %d.\n", vmode, cmode); + return -EINVAL; + } + + par->vmode = vmode; + par->cmode = cmode; + par->init = init; + par->xres = var->xres; + par->yres = var->yres; + par->vxres = par->xres; + par->vyres = par->yres; + + return 0; +} + +static void valkyrie_init_fix(struct fb_fix_screeninfo *fix, struct fb_info_valkyrie *p) +{ + memset(fix, 0, sizeof(*fix)); + strcpy(fix->id, "valkyrie"); + fix->mmio_start = p->valkyrie_regs_phys; + fix->mmio_len = sizeof(struct valkyrie_regs); + fix->type = FB_TYPE_PACKED_PIXELS; + fix->smem_start = p->frame_buffer_phys + 0x1000; + fix->smem_len = p->total_vram; + + fix->type_aux = 0; + fix->ywrapstep = 0; + fix->ypanstep = 0; + fix->xpanstep = 0; + +} + +/* Fix must already be inited above */ +static void valkyrie_par_to_fix(struct fb_par_valkyrie *par, + struct fb_fix_screeninfo *fix) +{ + fix->smem_len = valkyrie_vram_reqd(par->vmode, par->cmode); + fix->visual = (par->cmode == CMODE_8) ? + FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_DIRECTCOLOR; + fix->line_length = par->vxres << par->cmode; + /* ywrapstep, xpanstep, ypanstep */ +} + +static int __init valkyrie_init_info(struct fb_info *info, + struct fb_info_valkyrie *p) +{ + info->fbops = &valkyriefb_ops; + info->screen_base = p->frame_buffer + 0x1000; + info->flags = FBINFO_DEFAULT; + info->pseudo_palette = p->pseudo_palette; + info->par = &p->par; + return fb_alloc_cmap(&info->cmap, 256, 0); +} + + +/* + * Parse user specified options (`video=valkyriefb:') + */ +static int __init valkyriefb_setup(char *options) +{ + char *this_opt; + + if (!options || !*options) + return 0; + + while ((this_opt = strsep(&options, ",")) != NULL) { + if (!strncmp(this_opt, "vmode:", 6)) { + int vmode = simple_strtoul(this_opt+6, NULL, 0); + if (vmode > 0 && vmode <= VMODE_MAX) + default_vmode = vmode; + } + else if (!strncmp(this_opt, "cmode:", 6)) { + int depth = simple_strtoul(this_opt+6, NULL, 0); + switch (depth) { + case 8: + default_cmode = CMODE_8; + break; + case 15: + case 16: + default_cmode = CMODE_16; + break; + } + } + } + return 0; +} + +module_init(valkyriefb_init); +MODULE_LICENSE("GPL"); -- cgit v1.2.3