text:
Difference between revisions of "Linux/MIPS Porting Guide"
(→References: Fixup URLs)
(→Kernel Oops: Fixup URLs)
|Line 648:
|Line 648:
=== Kernel Oops ===
=== Kernel Oops ===
ksymoops is a program that deciphers all the secret numbers in a kernel core dump. Old versions of ksymoops may not work well for MIPS.
ksymoopsis a program that deciphers all the secret numbers in a kernel core dump. Old versions of ksymoopsmay not work well for MIPS.
I sometimes use a script, [
I sometimes use a script, [call2sym ], written by Phil Hollenback. You just cut and past the call trace part to feed the script and it will display a possible function call stack at the time crash. Note it is likely some symbols are bogus, but the real ones should be displayed. You will have to use your own judgement.
In 2.6, the brack trace is automatically printed for you when a kernel core dump happens.
In 2.6, the brack trace is automatically printed for you when a kernel core dump happens.
Revision as of 00:29, 22 October 2005
- 1 Prefix
- 2 An Overview
- 3 "Hello, world!"
- 4 Add your own code
- 5 Early printk()
- 6 Serial driver and console
- 7 kgdb
- 8 CPU support
- 9 Interrupts
- 10 System time and timer
- 11 PCI subsystem
- 12 Ethernet drivers and networking
- 13 ROMFS root filesystem
- 14 Debugging
- 15 Appendix A: Linux startup sequence in 2.4.x
- 16 Appendix B: Credits and thanks
This document reflects what I have learned through porting several MIPS machines and other related Linux work. Hopefully it will help beginners to get started and give the experienced a reference point.
This document goes through all the major steps to port Linux to a MIPS machine. The focus can perhaps be called "MIPS machine abstraction layer", i.e., the interface between machine-specific code and, mostly, MIPS common code. Another useful document focuses on "Linux hardware abstraction layer", i.e., the interface between Linux common code and architecture-specific code. The document is written by C Hanish Menon (www.hanishkvc.com).
There are some notations used in this document.
- Reminder for incomplete part
- Really need your help on this
- Here is my opinion. What do you think?
- Thanks to the person who pointed this out
- Additional note added later, but the original comment may be still useful
An Overview
- Know C programming.
- Have some knowledge of OS concepts, such as interrupt handling, system calls, memory management.
- Know how to configure and make Linux kernel. You can find many helps on this if you are not very comfortable.
- Have some knowledge of MIPS CPU. More than likely you will need to deal with CP0 registers, enable or disable interrupts, etc..
- You don't have to be an expert in MIPS assembly, but total ignorance of it might make you handicapped in some situations.
- Obviously, you need a MIPS hardware to play with.
- Finally but most importantly, you need a willing-to-learn heart and perhaps many restless debugging hours. :-)
It is also highly recommanded to read through the Linux MIPS HOWTO by Ralf Baechle, email@example.com. By the way, as part of the pre-requisite, you should also remember Ralf's name. :-)
Kernel source trees
The common MIPS tree is the CVS tree at linux-mips.org. See the instructions in "Anonymous CVS servers" section in Linux/MIPS HOWTO. The current kernel version as of 2004/01/26 is 2.6.1. You can always check out earlier stable revisions by using "linux_2_4" or even "linux_2_2" branch tag.
Kernel patches
For various reasons, a kernel tree may leave bugs there for a quite long time before a suitable fix is checked in. There are various places to get patches. Here are some of the more common ones:
Cross-compilation and toolchains
More than likely your MIPS box does not run Linux yet (why would you bother otherwise?). Therefore you will need another machine to build the kernel image. Once the image is built, you need to download this image to your MIPS machine and let it run your MIPS kernel. This is called cross-development. Your MIPS box is often called the target machine and the machine used to build the kernel image is called the host machine.
Cross-development is common for developing on embedded targets, because usually embedded targets do not have enough power or the peripherals to develop natively.
The most common host machine is probably Linux on i386/PCs.
You need to have cross-development tools setup on your host before you can start. While you can find instructions, such as in Linux/MIPS HOWTO, to build cross-compilation tools, your best bet is probably to get some ready-made ones.
MontaVista used to offer for free Journeyman edition, which includes a full featured toolchain. Unfortunately, it does not offer that anymore. Instead you can download the preview kit, which includes a "slim" version of toolchain. You can get the kit from http://www.mvista.com/previewkit/index.html
Dan Kegel has a set of scripts that build cross-compiling tools. You can check it out here.
The following are links to pre-build toolchains, instructions to build your own toolchain and finally pre-compiled distributions for MIPS boards:
- Brad LaRonde's cross toolchain for Linux
- Steve Hill's toolchains for glibc and uClibc
- MIPS free toolchains
- Distributions for MIPS
Overall porting steps
Depending on your specific cases, some of the following steps can be skipped.
- Hello World! - Get board setup, serial porting working, and print out "Hello, world!" through the serial port.
- Add your own code.
- Get early printk working - Make the first MIPS image and see the printk output from kernel.
- Serial driver and serial console - Get the real printk working with the serial console.
- KGDB - KGDB can be enormously helpful in your development. It is highly recommended and it is not that difficult to set up.
- CPU support - If your MIPS CPU is not currently supported, you need to add new code that supports it.
- Board specific support - Create your board-specific directory. Setup interrupt routing/handling and kernel timer services.
- PCI subsystems - If your machine has PCI, you need to get the PCI subsystem working before you can use PCI devices.
- Ethernet drivers - You should already have the serial port working before attempting this. Usually the next driver you want is the ethernet driver. With ethernet driver working, you can set up a NFS root file system which gives you a fully working Linux userland.
- ROMFS root file system - Alternatively you can create a userland file system as a ROMFS image stored in a ramdisk.
"Hello, world!"
In cross development, the serial port is usually the most important interface: That is where you can see anything happening! It might be worthwhile to make sure you get serial porting work before you even start playing with Linux. You can find the sample code or gzipped tar ball of a stand-alone program that can do printf. Such a program can even be useful in later debugging staging, e.g., printing out hardware register values.
Before you rush to type 'make', check and modify the following configurations:
- The sample code assumes R4K style CP0 structure. It should apply to most CPUs named above number 4000 and the recent MIPS32/MIPS64.
- Check if you have 1MB RAM size. (You really should have at 1MB to run Linux at all.) It is recommanded you have 8MB RAM or more.
- Is your serial port a standard UART type? If yes, modify the serial code and parameters. If not, you will have to supply your own functions to utilize the UART.
- What is your cross-tool name and path? Modify the Makefile accordingly.
Now, fire your "make" command.
Depending on your downloader on your MIPS box, you may need to generate ELF image, binary image or a SREC image.
Download the barebone image to your target and give it a run! Connect the serial port to your host machine. Start minicom and hopefully you can see the "Hello, world!" message.
Trouble shooting:
- Make sure your bootloader downloads the image to uncached KSEG1 segment. If your bootloader downloads to the cached KSEG0 area, you will want to run the image from the KSEG0 area too.
- If your bootloader has already initialized the serial port, you may want to skip your own initialization.
- Did you set up minicom correctly? Test it with other machines.
- Hopefully it is not the toolchain problem...
Add your own code
Let us add some code to the tree and make a Linux image. For conveninence sake, let us say we are porting Linux to a MIPS board called Aloha.
Create the right directory for your board
Your code for a new board can be classified into board-support code (or board-specific code) and drivers. Driver code should be placed under the 'drivers' directory and board specific code should be placed under 'arch/mips' directory.
The easiest choice is to create a directory called 'arch/mips/aloha'.
However, a couple of other considerations might make it slightly complicated.
- If Aloha uses a chipset or System on a Chip (SOC) that is already supported or belongs to a bigger family, such as NEC VR41xx and gt64120, it makes sense to put Aloha code under those sub-directories. You can re-use and share a lot of common code.
- Similarly, if Aloha is the first board that uses a chipset or SOC which is expected to be used in many other boards, you may want to create similar directory structure. However, if you are not sure, just create your own board specific directory.
In the past people have created directories based on the board manufacturer's name, such as "mips-boards". This generally is not a good idea. It is almost certain that some of these boards do not share anything common at all.
To make things worse, sometimes boards made by different companies use the same chipset or SOC. Now what are you going to do? Are you going to duplicate the common code? Or are you going stick one company's board under another company's name?
For header files, you usually create similar directory or header files under include/asm-mips. [DEBATE] For board specific header files, I would encourage people to place them under the corresponding 'arch/mips' directory if possible.
In our exmaple, we will create 'arch/mips/aloha' directory.
Write the minimum Aloha code
Let us write some code for the Aloha board which can generate a complete Linux image without complaining about missing symbols.
Go to this directory to browse arch/mips/aloha/ directory. Or download the gzipped file of the directory.
Obviously the code is not complete yet, but if you follow the following steps and everything is correct, you should be able to generate a Linux/MIPS kernel image of your very own!
Hook up your code with the Linux tree
Most of the steps are fairly straightforward:
- include/asm-mips/bootinfo.h - Add your machine group ID, machine group name and Aloha machine ID.
- arch/mips/kernel/setup.c - Add 'aloha_setup' function declaration and invocation code.
- arch/mips/Makefile - Add a section that links your Aloha code in.
# # Hawaii Aloha board # ifdef CONFIG_ALOHA SUBDIRS += arch/mips/aloha LIBS += arch/mips/aloha/aloha.o LOADADDR += 0x80002000 endif
LOADADDR is the starting address for your Linux image when it is loaded into RAM. Note that the first
0x200 bytes are used by the exception vectors on most CPUs. Some CPUs will requries a larger space, so modify the
LOADADDR accordingly. Due to the linker's addressing limit, the start address is aligned on a 8KB boundary, so setting your
LOADADDR to
0x80002000 should be reasonable.
- arch/mips/config-shared.in - Add necessary config information for Aloha board.
- Add the following to 'Machine selection'.
dep_bool 'Support for Hawaii Aloha board (EXPERIMENTAL)' CONFIG_ALOHA $CONFIG_EXPERIMENTAL
- Add a set of default configs for the board, which depends on the features and drivers that Linux port will supports. Here is a very simple example for our minimum Aloha board configurations.
if [ "$CONFIG_ALOHA" = "y" ]; then define_bool CONFIG_CPU_R4X00 y define_bool CONFIG_CPU_LITTLE_ENDIAN y define_bool CONFIG_SERIAL y define_bool CONFIG_SERIAL_MANY_PORTS y define_bool CONFIG_NEW_IRQ y define_bool CONFIG_NEW_TIME_C y define_bool CONFIG_SCSI n fi
There are two kinds of configuration options here. The first kind are those you cannot select interactively during
'make config' or
'make menuconfig' or
'make xconfig'. Examples are
CONFIG_NEW_IRQ and
CONFIG_NEW_TIME_C. You must put them here, or else they will not get selected. The second kind of options are those you can select interactively, such as
CONFIG_CPU_R4X00 and
CONFIG_SERIAL. However you may also put them here if you know which selection is right for the board. This way people will make fewer mistakes when they configure for the board.
For instant gratification, you can find a complete patch for adding the Aloha board support to the Linux/MIPS CVS tree checked out on January 20, 2004.
Configure and build a kernel image
Now you are ready to run your favorite configuration tool. Since we do not have much code added yet, do not be too greedy with selecting options. Just pick a couple of simple options such as the serial and serial console.
- If you denoted the Aloha board support to be EXPERIMENTAL, select 'Prompt for development and/or incomplete code/drivers' under 'Code maturity level options'.
- Select 'Support for Hawaii Aloha board' and unselect all other machines under 'Machine selection'.
- Select the right CPU. Under 'CPU selection' select your CPU. If there is no entry for the CPU on your board, you will need to add support for it. Most recent CPUs can generally run to some degree with CPU_R4X00.
- Under 'Character devices', select 'Standard/generic (8250/16550 and compatible UARTs) serial support' and 'Support for console on serial port'. Unselect the 'Virtual terminal' option.
- Under the 'Kernel hacking' option, select 'Are you using a crosscompiler'.
- For other options either take the default or select 'no'.
Here is a sample minimum config for our Aloha board.
Before you type
make, double-check the arch/mips/Makefile and make sure the cross-toolchain program names are correct and in your execution path i.e. your
PATH environment variable.
Now type
make dep and
make. Then wait for a miracle to happen!
Early printk()
Assuming you are lucky and actually generate an image from the last chapter, don't bother running it because you won't see anything. This is not strange because all our board-specific code is empty and we have not told Linux kernel anything about our serial port or I/O devices yet.
The sign of a live Linux kernel comes from the output of printk, which is routed to the first console. Since we have configured a serial console, we should be able to see something on the serial wire if we have set it up correctly.
Unfortunately, setup of the serial console happens much later during the kernel startup process. (See Appendix A for a chart of the kernel start-up sequence). Chances are your new kernel probably dies even before that. That is where the early printk patch comes in handy. It allows you to see printk as early as the first line of C code.
By the way the first line of C code for Linux MIPS is the first line of code of 'init_arch()' function in the 'arch/mips/setup.c' file.
For kernel version earlier than 2.4.10, you can find the early printk patch here for boards with standard UART serial ports. Starting from 2.4.10 and beyond, a new printk patch is needed. If you have already got the stand-alone "Hello, world!" program running, the early printk should be easy to get going, and you should have printk output from the Linux kernel very soon.
Serial driver and console
While early printk is rather useful, you still need to get the real serial driver working.
Assuming you have a standard serial port, there are two ways to add serial support: static defines and run-time setup.
With static defines, you modify the 'include/asm-mips/serial.h' file. Looking through the code, it is not difficult to figure out how to add support for your board's serial port(s).
As more boards are supported by Linux/MIPS, the 'serial.h' file gets crowded. One potential solution is to do run-time serial setup. Sometimes run-time serial setup is necessary if any of the parameters can only be detected at the run-time where settings are read from a non-volatile memory device or an option is passed on the kernel command line.
There are two elements to consider for doing run-time serial setup:
- Reserve the
rs_table[]size, see the drivers/char/serial.c file. Unfortunately there is not a clean way to accomplish this yet. A temporary workaround is to define
CONFIG_SERIAL_MANY_PORTSin arch/mips/config-shared.in for your board. This configuration reserves up to 64 serial port entries for your board!
- Call the
early_serial_setup()routine in your board setup routine. Here is a piece of sample run-time initialization code.
Serial parameters
Most of the parameter settings are rather obvious. Here is a list of some less obvious ones:
Only used for run-time serial configuration. It is the index into the 'rs_table[] array'.
io_type determines how your serial registers are accessed. Two common types are SERIAL_IO_PORT and SERIAL_IO_MEM. A SERIAL_IO_PORT type driver uses the inb/outb macros to access registers whose base address is at port. In other words, if you specify SERIAL_IO_PORT as the io_type, you should also specify the port parameter.
For SERIAL_IO_MEM, the driver uses readb/writeb macros to access regsiters whose address is at iomem_base plus a shifted offset. The number of digits shifted is specified by iomem_reg_shift. For example, all the serial registers are placed at 4-byte boundary, then you have an iomem_reg_shift of 2.
Generally SERIAL_IO_PORT is for serial ports on an ISA bus and SERIAL_IO_MEM is for memory-mapped serial ports.
There are also SERIAL_IO_HUB6 and SERIAL_IO_GSC. The HUB6 was a multi-port serial card produced by Bell Technologies. The GSC is a special bus found on PA-RISC systems. These options will not be used on any MIPS boards.
Non-standard serial ports
If you have a non-standard serial port, you will have to write your own serial driver.
Some people derive their code from the standard serial driver. Unfortunately this is a very daunting task. The 'drivers/char/serial.c' file has over 6000 lines of code!
Fortunately, there is an alternative [THANKS: Fillod Stephane]. There is a generic serial driver, 'drivers/char/generic_serial.c'. This file provides a set of serial routines that are hardware independent. Then your task is to provide only the routines that are hardware dependent such as the interrupt handler routine and low-level I/O functions. There are plenty of examples. Just look inside the 'drivers/char/Makefile' and look for drivers that link with 'generic_serial.o' file.
[HELP: Would appreciate if you can share your experience of writing proprietary serial driver code or using the 'generic_serial.c' file.]
For many Linux kernel developers, KGDB is a life-saving tool. With KGDB, you can debug the kernel while it runs! You can set breakpoints or do single stepping at the source code level.
To do this, you will need a dedicated serial port on your target, and use a crossover-cable (also known as a null-modem) to connect it to your development host. If you are also using a serial console, this implies you will need two serial ports on your target. It is possible to do both kernel debug and serial console through a single serial port. This will be mentioned later in this chapter.
When you configure the kernel, select the
Remote GDB kernel debugging which is listed under
Kernel hacking. Do a
make clean and recompile the kernel so that debugging symbols are compiled into your kernel image. Try to make a new image. You will soon discover two missing symbols in the final linking stage:
arch/mips/kernel/kernel.o: In function `getpacket': arch/mips/kernel/kernel.o(.text+0x85ac): undefined reference to `getDebugChar' arch/mips/kernel/kernel.o(.text+0x85cc): undefined reference to `getDebugChar' arch/mips/kernel/kernel.o(.text+0x8634): undefined reference to `getDebugChar' arch/mips/kernel/kernel.o(.text+0x864c): undefined reference to `getDebugChar' arch/mips/kernel/kernel.o(.text+0x8670): undefined reference to `putDebugChar' arch/mips/kernel/kernel.o(.text+0x8680): undefined reference to `putDebugChar' arch/mips/kernel/kernel.o(.text+0x8698): undefined reference to `putDebugChar' arch/mips/kernel/kernel.o(.text+0x86a0): undefined reference to `putDebugChar'
You need to supply these two functions for your own boards:
int putDebugChar(uint8 byte) uint8 getDebugChar(void)
As an example, here is the dbg_io.c for DDB5476 board. DDB5476 uses a standard UART serial port to implement those two functions.
After supplying those two functions, you are ready to debug the kernel. Run the new kernel image. If you also use the early printk patch, you should be able to see something like this on your console:
Wait for gdb client connection ...
Assuming you have already connected a cross-over serial cable between the dedicated serial port on the target and a serial port on your host (say, COM0), you can then set the appropriate baud rate and start the cross gdb on your host:
stty -F /dev/ttyS0 38400 mipsel-linux-gdb vmlinux
At the gdb prompt, type
target remote /dev/ttyS0
And, voila! You should be talking to the kernel through KGDB - if you are lucky enough!
A couple of tips on using KGDB:
- Any functions preceded with the
__initlabel will not break very well with breakpoints. Sometimes it will screw up the line numbers of other functions in the same file. Try undefining
__initto be an empty macro in your include/linux/init.h file. Refer to the patch. [NOTE: This problem is fixed in the latest gdb version, at least in gdb 5.2]
- Sometimes if you break on a function, you cannot see the correct value in variables and cannot do back-tracing. This is probably because certain registers are still not initialized [HELP: because kernel is compiled with -O2 flag?]. Step into the function a couple of lines, and you should see the variable and back-tracing fine.
What if the board only has one serial port?
Some boards only have one serial port. If you use it as serial console, you cannot really use it for KGDB - unless you do some tricks to it.
There are two solutions. One is GDB console, and the other is to use a KGDB demuxing script.
It is easy to use the GDB console. When you select 'Remote GDB kernel debugging' under the 'Kernel hacking' sub-menu, you are also prompted for 'Console output to GDB'. Simply selecting that choice will work! In fact, this option is so easy to use you might want to use it even if you have a second serial port.
However, this option has a limit. When the kernel goes to userland, the console stops working. This is because the KGDB stub in the kernel and GDB are not designed to provide interactive output. [HELP: any volunteers?]
The second option uses a script called 'kgdb_demux' written by Brian Moyle. It creates two virtual ports, typically ttya0 and ttya1. It then listens to the real serial port (such as ttyS0). It will forward console traffic to ttya0 and KGDB traffic to ttya1. All you have to do then is to start minicom on /dev/ttya0 (port setting does not matter) and KGDB on
You can download the tarball here. A couple of usage tips.
- Untar the file to some place.
- Copy kgdb_demux script to your execution path, and modify it properly.
- Set the port parameters properly before you start kgdb_demux.
CPU support
In the MIPS world, there are different families of MIPS cores. For example Toshiba TX49, SiByte SB1, NEC VR41XX, MIPS32, and MIPS64 to name a few. These different families may have different cache architectures, may be 32-bit or 64-bit, and may or may not have a FP unit. A complete list of families is found in the 'arch/mips/config-shared.in' and 'include/asm-mips/cpu.h' files. When you are configuring your kernel the complete list will appear under the 'CPU type' menu selection. If you are adding support for an entirely new family of MIPS cores, you will need to change the following files:
- arch/mips/config-shared.in - You will need to add your processor family to the list under 'CPU type'.
- include/asm-mip/cpu.h - You will need to add a PRID_COMP and PRID_IMP entries for your processor family if they do not already exist. You will also need to then add the CPU types that you will support in that family. Adding CPU types is covered below.
- arch/mips/kernel/cpu-probe.c - For each processor family, there is typically a cpu_probe_XXX function that probes and fills in the struct cpuinfo_mips which contains information about the CPU type, whether a FP unit exists, the number of TLBs available, etc. Your function is responsible for properly probing and filling in this information for the entire family of processors. Finally, if your family does something special for CPU idle, then you will have to define a 'wait' function. Most likely, you will be able to use one that already exists. If not, add your 'wait' function and enable detection of it in check_wait.
- arch/mips/mm - If your processor family has a unique cache architecture or anything out of the ordinary, you will need to either add or modify files in this directory.
Within each family of MIPS cores, there are multiple processors. For example, Alchemy processors and Broadcom processors are in the MIPS32 family, the Sibyte 1250 is in the SB1 family, and so on. Once you have decided what family your processor is in, you need to verify that a unique CPU identification exists for it. The 'include/asm-mips/cpu.h' file contains all of the currently supported CPU types for the Linux/MIPS kernel.
If your processor is already listed in the 'include/asm-mips/cpu.h' file, the existing Linux/MIPS code should auto-detect it. If your processor is not listed, you will need to change three files to properly detect your processor:
- include/asm-mip/cpu.h - Add your processor at the end of the CPU_XXX definitions. Make sure you update the 'CPU_LAST' value to match that of the processor you added.
- arch/mips/kernel/proc.c - Add an entry to the cpu_name array so that your CPU name can be properly displayed in /proc/cpuinfo.
- arch/mips/kernel/cpu-probe.c - Add your processor into the case statement in the function check_wait if your CPU can do some sort of wait or idle operation. Add the necessary code in the cpu_probe_XX function to detect and set your CPU type.
Once you have support for your processor family and specific CPU type, you should be able to take full advantage of its capabilities.
It you followed the previous steps, most likely you will see kernel hanging at the BogusMIPS calibration step. The reason is simple: The interrupt code is not there and jiffies are never updated. Therefore the calibration can never be done.
Before you start writing interrupt code, it really pays to study the hardware first. Pay particular attention to identify all interrupt sources, their corresponding controllers and how they are routed.
Then you need to come up with a strategy, which typically includes:
- a static interrupt routing map
- a list of interrupt sources
- a list of their corresponding controllers
- how interrupt controllers cascade from each other
Interrupt code overview
To completely service an interrupt, four different pieces of code work together:
- IRQ detection/dispatching:
This is typically assembly code in a file called 'int_handler.S'. Sometimes there is also secondary-level dispatching code written in C for complicated IRQ detection. The end result is that we identify and select a single IRQ source, represented by an integer, and then pass it to function 'do_IRQ()'.
- do_IRQ()
do_IRQ() is provided in the 'arch/mips/kernel/irq.c' file. It provides a common framework for IRQ handling. It invokes the individual IRQ controller code to enable/disable a particular interrupt. It calls the driver supplied interrupt handling routine that does the real processing.
- hw_irq_handler
It is a structure associated with each IRQ source. The structure is a collection of function pointers, which tells do_IRQ() how it should deal with this particular IRQ.
- driver interrupt handling code
The code that does the real job.
Obviously for our porting purposes we need to write IRQ detection/disptaching code and the hw_irq_handler code for any new IRQ controller used in the system. In addition, there is also IRQ setup and initialization code.
CPU as an IRQ controller
Most R4K-compatible MIPS CPUs have the ability to support eight interrupt sources. The first two are software interrupts, and the last one is typically used for CPU counter interrupt. Therefore you can have up to five external interrupt sources.
Luckily if the CPU is the only IRQ controller in the system, you are done! The
hw_irq_handler code is written in arch/mips/kernel/irq_cpu.c file. All you have to do is to define
CONFIG_IRQ_CPU for your machine. And in your irq setup routine make sure you call
mips_cpu_irq_init(0). This call will initialize the interrupt descriptor and set up the IRQ numbers to range from 0 to 7.
You can also find a matching interrupt dispatching code in this file.
Set up cascading interrupts
More than likely you will have more interrupt sources than those that can directly connect to the CPU interrupt pins. A second or even third-level interrupt controller may connect to one or more of those CPU pins. In that case, you have cascading interrupts.
There are plenty of examples of how cascading interrupt works, such as the DDB5477 and the Osprey. Here is a short summary:
- Assign blocks of IRQ numbers to various interrupt controllers in the whole system. For example, in the case of the Osprey, CPU interrupts occupy IRQ 0 to 7. Vr4181 system interrupts occupy IRQ 8 to 39, and GPIO interrupts occupy 40 to 56. In most cases, the actual IRQ numbers do not matter, as long as the driver knows which IRQ number it should use. However, if you have an i8259 interrupt controller and an ISA bus, you should try to assign IRQ number 0 to 16 for the i8259 interrupts because it will make the legacy PC drivers happy. (Please note before ~12/08/2001 in version 2.4.16 of the Linux kernel, the 'i8259.c' file set the base vector to be 0x20. If you use the IRQ acknowledgement cycle to obtain the interrupt vector, you will get an IRQ number from 0x20 to 0x2f. You will then need to substract 0x20 from the return value to get the correct IRQ number.)
- Write the 'hw_irq_controller' member functinos for your specific controllers. Note that CPU and i8259 already have their code written. You just need to define appropriate CONFIG options for your board. See the next sub-section for more details about writing 'hw_irq_controller' member functions.
- In your IRQ setup routine, initialize all the controllers, usually by calling 'interrupt_controller_XXX_init()' functions.
- In your IRQ setup routine, setup the cascading IRQs. This setup will enable interrupts for the upper interrupt controller so that the lower-level interrupts can cascade through once they are enabled. A typical way of doing this is to have a dummy 'irqaction struct' and setup as follows:
static struct irqaction cascade = { no_action, SA_INTERRUPT, 0, "cascade", NULL, NULL }; extern int setup_irq(unsigned int irq, struct irqaction *irqaction); void __init <my>_irq_init(void) { .... setup_irq(CPU_IP3, &cascade); }
- You need to expand your interrupt dispatching code properly to identify the added interrupt sources. If the code is simple enough, you can do it in the same int_handler.S file. If it is more complicated, you may do it in a separate C function (such as in the DDB5476 board).
The hw_irq_controller struct
hw_irq_controller structure' is a defined in the 'include/linux/irq.h' file as an alias for the 'hw_interrupt_type' structure.
struct hw_interrupt_type { const char * typename; unsigned int (*startup)(unsigned int irq); void (*shutdown)(unsigned int irq); void (*enable)(unsigned int irq); void (*disable)(unsigned int irq); void (*ack)(unsigned int irq); void (*end)(unsigned int irq); void (*set_affinity)(unsigned int irq, unsigned long mask); };
The 'arch/mips/kernel/irq_cpu.c' is a good sample code to write 'hw_irq_controller' member functions. Here are some more programming notes for each of these functions:
const char * typename;
Controller name. Will be displayed under /proc/interrupts.
unsigned int (*startup)(unsigned int irq);
Invoked when request_irq() or setup_irq are called. You need to enable this interrupt here. Other than that you may also want to do some IRQ-specific initialization (such as turning on power for this interrupt, perhaps).
void (*shutdown)(unsigned int irq);
Invoked when free_irq() is called. You need to disable this interrupt and perhaps some other IRQ-specific cleanup.
void (*enable)(unsigned int irq) and void (*disable)(unsigned int irq)
They are used to implement enable_irq(), disable_irq() and disable_irq_nosync(), which in turn are used by driver code.
void (*ack)(unsigned int irq)
ack() is invoked at the beginning of do_IRQ() when we want to acknoledge an interrupt. I think you need also to disable this interrupt here so that you don't get recursive interrupts on the same interrupt source. [HELP: can someone confirm?]
void (*end)(unsigned int irq)
This is called by do_IRQ() after it has handled this interrupt. If you disabled interrupt in ack() function, you should enable it here. [HELP: generally what else we should do here?]
void (*set_affinity)(unsigned int irq, unsigned long mask)
This is used in SMP machines to set up interrupt handling affinity with certain CPUs. [TODO] [HELP]
The IRQ initialization code
The IRQ initialization is done in 'init_IRQ()'. Currently it is supplied by each individual board. In the future, it will probably be a MIPS common routine, which will further invoke a board-specific function, board_irq_init(). board_irq_init will be a function pointer that <my_board>_setup() function needs to assign propoer value.
In any case, the following is a skeleton code for a normal init_IRQ() routine.
extern asmlinkage void vr4181_handle_irq(void); extern void breakpoint(void); extern int setup_irq(unsigned int irq, struct irqaction *irqaction); extern void mips_cpu_irq_init(u32 irq_base); extern void init_generic_irq(void); static struct irqaction cascade = { no_action, SA_INTERRUPT, 0, "cascade", NULL, NULL }; static struct irqaction reserved = { no_action, SA_INTERRUPT, 0, "reserved", NULL, NULL }; static struct irqaction error_irq = { error_action, SA_INTERRUPT, 0, "error", NULL, NULL }; void __init init_IRQ(void) { int i; extern irq_desc_t irq_desc[]; /* hardware initialization code */ .... /* this is the routine defined in int_handler.S file */ set_except_vector(0, my_irq_dispatcher); /* setup the default irq descriptor */ init_generic_irq(); /* init all interrupt controllers */ mips_cpu_irq_init(CPU_IRQ_BASE); .... /* set up cascading IRQ */ setup_irq(CPU_IRQ_IP3, &cascade); /* set up reserved IRQ so that others can not mistakingly request * it later. */ setup_irq(CPU_IRQ_IP4, &reserved); #ifdef CONFIG_DEBUG /* setup debug IRQ so that if that interrupt happens, we can * capture it. */ setup_irq(CPU_IRQ_IP4, &error_irq); #endif #ifdef CONFIG_REMOTE_DEBUG printk("Setting debug traps - please connect the remote debugger.\n"); set_debug_traps(); breakpoint(); #endif }
Final notes
What is described in this chapter is what is so-called new style interrupt handling. We used to have three different ways to handle interrupts: new style (CONFIG_NEW_IRQ), the old style (CONFIG_ROTTEN_IRQ) and board-private ad hoc routines. New style is now the only valid method since October 2002.
System time and timer
Linux relies on an RTC (real-time clock) device to obtain the real calendar data and time when it boots up. It relies on a system timer to advance the tick count, jiffies. If you don't provide proper time and timer code, Linux won't run. In fact it will stick in 'calibrate_delay()' during the startup process because jiffies is never incremented. (See Appendix B for more details about Linux/MIPS startup sequence).
There is an excellent document (I becomes a little shameless. :-0) under 'Documentations/mips/time.README' that should be read to further understand timekeeping for Linux/MIPS. It is a must read.
Here are some comments on implementing time and timer services:
- If your system has a CPU counter and another hardware timer, use the hardware timer over the CPU counter, even though CPU counter might be easier to setup and use. This is because CPU counter relies on the CPU frequency which is more likely to change in the future. In addition, performance-critical code may need to access the CPU counter for its own measurements. Some CPUs may have a variable CPU frequency which makes CPU counter not usable as a timer source. [DEBATE: 03/12/04, I changed my preference on this issue. Linux in the future will have richer and higher resolution time support. If all MIPS boards use CPU counter as the system timer, we can maximize the code sharing.]
- Unless you have to use interrupts to calibrate the CPU frequency, you can generally avoid implementing the 'board_time_init()' function. Most of its work can be done in the board setup routine.
- When you implement 'rtc_set_time()', more than likely you need to call the 'to_tm()' function which converts a single jiffy value to a full 'struct rtc_time'. This function is provided in 'arch/mips/kernel/time.c' and declared in 'include/asm-mips/time.h'.
PCI subsystem
The PCI subsystem is perhaps the most complex code you have to deal with during the porting process. The key to making the PCI subsystem work properly is a good understanding of the PCI bus itself, the code layout, and the execution flow in Linux. Like many other parts of porting, you will find in the end, the actual code writen is minimumal.
Pete Popov wrote a fine document on PCI and Linux/MIPS. It is under Documentation/mips/pci/pci.README. It is highly recommended reading.
For those who want to know more about the PCI bus itself, I recommend the book PCI System Architecture (ISBN 0201309742) published by MindShare Inc.
Overview of the PCI bus
Here we summarize some facts of the PCI bus:
- The PCI bus has three separate address spaces, config, I/O, and memory space.
- Every PCI device responds to config commands, and it can respond to I/O accesses and/or memory accesses.
- During the boot time, the BIOS or the OS sets the base address registers (BARs) through configuration space. BARs determine address ranges in I/O or memory space that a device should respond to. Obviously, those ranges should not be duplicated anywhere else in the I/O space or memory space on the same PCI bus.
- Multiple PCI buses can be connected through PCI-PCI bridges.
BAR assignment in Linux
On all IBM PC-compatible machines, BARs are assigned by the BIOS. Linux simply scans through the buses and records the BAR values.
Some MIPS boards adopt similar approaches, where BARs are assigned by firmware. However, the quality of BAR assignment by firmware vary quite a bit. Some firmware simply assigns BARs to on-board PCI devices and ignore all add-on PCI cards. In that case, Linux cannot solely rely on the firmware's assignment.
There is another issue of depending on the firmware assignment. You need to stick with the address range setup by the firmware. In other words, if the firmware assigns PCI memory space from 0x10000000 to 0x14000000, you cannot easily move it to a different address space somewhere else in Linux.
There three ways to possibly fix this:
- The first way is to fix the BAR assignment manually in your board setup routine. This only works if your board does not have a PCI slot to plug in an arbitrary PCI card. You need to carefully examine the existing PCI resource assignment done by firmware so that you do not assign overlapping address ranges.
- The second way is to do a complete PCI resource assignment *before* Linux starts PCI bus scanning. In other words, we discard any PCI resource assignment done in firmware, if there is any, and do a new assignment by ourselves. This approach gives us complete control over the address range and resource allocation. With the CONFIG_PCI_AUTO option used in 'arch/mips/config-shared.in' and 'arch/mips/kernel/pci_auto.c' file, it turns out to be quite easy to do. This approach is the focus of this chapter.
- Another approach is to call the 'pci_assign_unassigned_resources()' function, which is defined in the 'drivers/pci/setup-bus.c' file in recent 2.4.x kernels *after* Linux completes the PCI bus scan. With earlier versions of this function, Linux will assign resources to PCI devices whose BAR have *not* been properly assigned. With the recent versions (that have "optimal" resource assignment based on sizes), this PCI routine apparently does a complete resource re-assignment. In other words, it does almost exactly the same as what the 'pci_auto.c' file does.
[DEBATE] The 'pci_auto' and 'assign_unassigned_resource' approaches have their own advantages and disadvantages. Ideally, the whole PCI subsystem should be completely re-written so that several things can be taken into consideration which are not currently addressed:
- A notion of a host-PCI controller, and supporting multiple host-PCI controllers.
- A kernel-independent abstraction layer to access configuration space, distinguishing Type 0 and Type 1 configuration accesses. This removes the need for 'pci_dev' in the lowest-level PCI routines.
- Pass 1 scan to do bus number assignment and record bus topology through the top-level host-PCI controller structure.
- Pass 2 scan to discover all other PCI devices and assign the resources along the way.
- If we want to do optimal resource assignment, we need to do the resource assignment in Pass 3 instead of Pass 2.
- A complete PCI device list is built during the above passes.
- The address range for PCI memory space and I/O space are set when host-PCI controller structures are initially created.
PCI startup sequence
- do_basic_setup() calls pci_init(), which is defined in 'drivers/pci/pci.c'.
- pci_init() first calls pcibios_init(). If you enable CONFIG_NEW_PCI, pcibios_init() is implemented in the 'arch/mips/kernel/pci.c' file. Otherwise you need to provide it in your own board-dependent code.
- Optionally, pcibios_init() may call pciauto_assign_resources() to do a complete PCI resource assignment.
- Somewhere inside pcibios_init(), pci_scan_bus() is called. If a machine has multiple host-PCI controllers, pci_scan_bus() should be called for each of the top-level PCI buses. Apparently, bus numbers should have already been setup before pci_scan_bus() can properly run.
- Optionally, after pci_scan_bus() is called, pcibios_init() may choose to call pci_assign_unassigned_resources() to do a complete PCI resource assignment.
- pcibios_init() will do some more fixups (resources, IRQs, etc.).
- Returning from pcibios_init(), pci_init() will do a final round of device-based fixups.
In this chapter, we focus on the approach where both CONFIG_NEW_PCI and CONFIG_PCI_AUTO are enabled.
PCI driver interface
All of this work for PCI is to eventually setup a structure where all PCI device drivers can run happily. Knowing how PCI device drivers access PCI resources can greatly help you understand how you should do PCI initialization and setup.
- inb()/outb()/inw()/outw()/inl()/outl()
Defined in 'include/asm-mips/io.h'. Drivers use these macros to read/write into PCI IO space. The address arguments are addresses in PCI IO space, and should correspond to one of the BAR values of the device. On MIPS machines, we assume PCI IO space is mapped into a contiguous physical address block. The base address of the block is mips_io_port_base, which you need to set up at the beginning of board setup time. The proper way to set it up is call set_io_port_base().
- readb()/writeb()/readw()/writew()/readl()/writel()
Defined in the 'include/asm-mips/io.h' file. Drivers use them to access PCI memory space. On MIPS machines, we assume PCI memory space is 1:1 mapped into a block of physical address. Therefore those macros are equivalent to direct physical memory access.
- pci_read_config_word() and friends
Defined in 'include/linux.pci.h' (through PCI_OP()). Drivers use them to read or write the configuration registers of devices. Low-level routines are abstracted as struct pci_ops, where each board must supply one.
- pci_map_single() and friends
Defined in 'include/asm-mips/pci.h'. Drivers use these macros to map a virtual address to a bus address (so you can tell the device to do DMA). They don't usually affect PCI porting.
Setting up the host-PCI controller
As we can see from the above discussion, we need to set up the host-PCI controller such that:
- It has a 1:1 mapping between PCI memory space and CPU physical address space
- It maps the beginning part of PCI IO space into a address block in physical address space.
The Host-PCI controller usually allows you to map PCI memory space into a window in physical address space. Let us say the base address is ba_mem and size is sz_mem. It usually allows you to translate that address into another one with a fixed offset, say off. (Note off can be both positive or negative). So if a driver accesses the address ba_mem+x (0 <= x < sz_mem), the host-PCI controller will intercept the command and translate it into a PCI memory access at address ba_mem+off+x.
To maintain 1:1 mapping, it implies we must set up the PCI addressing such that off is 0. Also note that with this setup, we cannot access the PCI memory range [0x0, ba_mem] and [ba_mem + sz_mem, 0xffffffff].
Additionaly, we must also make system RAM visible on the PCI memory bus at address 0x0 (assuming that is the address in physical address space) in order for PCI devices to do DMA transfers.
The beginning part of PCI IO space is usually mapped into another window in physical address space, say [ba_io, ba_io + sz_io]. In other words, a range [0, sz_io] in PCI IO space corresponds to the range [ba_io, ba_io + sz_io]. Obviously, mips_io_port_base should be set to ba_io.
The above setup is typically done in the board-specific setup routine (i.e., <board>_setup()). You typically also setup ioport_resource and iomem_resource as well:
ioport_resource.start = 0x0; ioport_resource.end = sz_io; iomem_resource.start = 0x0; iomem_resource.end = sz_mem;
These variables are the roots of all IO and memory resources (roughly corresponding to the ancient ISA IO space and ISA memory space). For simplicity you can also set the end to be 0xffffffff.
Board-specific functions and variables
Here is a list of board-specific functions you must implement. Again, I assume this board has CONFIG_NEW_PCI and CONFIG_PCI_AUTO options enabled.
- struct pci_ops my_pci_ops
You implement six functions to fill into this structure, which is needed by pci_scan_bus() and pciauto_assign_resources(). Note that you need to dintinguish type 0 or type 1 configuration in those functions. You can typically check that by checking whether the bus's parent (dev->bus->parent) is NULL.
- mips_pci_channels[]
You need to define this array in order to use pciauto resource assignment. For each top-level PCI bus, you need to supply an element data to this array. The array ends with an all-NULL element. Each element is a structure that consists a pci_ops, pci_io_resource, and pci_mem_resource, which usually represents a top-level PCI bus connected to CPU. pci_ops defines the functions access the PCI bus's config space. pci_io_resource and pci_mem_resource specifies the address range that pciauto will use to assign to the BARs of PCI devices. For pci_io_resource, it starts with 0x0 (or 0x1000 to leave some room for legacy ISA devices), and it ends at sz_io. For pci_mem_resource, it starts at ba_mem and ends at ba_mem + sz_mem. Note these addresses are in PCI IO and PCI memory space respectively. However, since we maintain 1:1 mapping between PCI memory space and CPU physical address space, pci_mem_resource also represents the PCI memory space window in CPU physical address space.
- pcibios_fixup_resources()
This routine is passed to pci_scan_bus() and invoked right after when the PCI device is discovered. This is place where you can do some device-specific fixup (BARs, pci_dev structure, etc). Note you can do the same fixup in pcibios_fixup(). I recommand leave this function empty unless you have some specific need that requires immediate fixup.
- pcibios_fixup()
This function is invoked after pci_scan_bus() is done, i.e., all PCI bridges and devices are discovered by Linux. Here you can enumerate through PCI devices and do device based fixup. Or you can do bus or contoller related fixups.
- pcibios_fixup_irqs()
This is the place to fix up PCI related IRQs. It is invoked after pci_scan_bus() is done and next to pcibios_fixup(). A typical strategy is to assign irq based on the slot number and possibly bus number if there are more than top-level buses in the system. Note that you can do the fixup in pcibios_fixup() as well and leave this function empty.
- pcibios_assign_all_busses()
Return 1 to indicate that all bus numbers have been assigned by pciauto. [TODO:Should this function be included in pciauto by default?][TODO: the driver/pci/pci.c file seems to have a typo when it calls this function. The logic is inversed.]
Tips for writting PCI code
- Some ill-behaviored PCI device may spoil the party. The best way to deal with them is to signle them out in the PCI configuration routines (in pci_ops). Inside those routines you check for the slot number and function number corresponding to the bad devices and return some NULL numbers.
- If you have mulitple top-level PCI buses, it is tricky to do PCI IO assignment. Assume you have two PCI buses and their IO spaces are mapped into [ba_io1, ba_io1 + sz_io1] and [ba_io2, ba_io2+sz_io2] (ba_io1 + sz_io1 <= ba_io2). You need to
- Set mips_io_port_base to be ba_io1
- Set pci_io_resource to be [0x0, sz_io1] for the first PCI bus
- Set pci_io_resource to be [ba_io2 - ba_io1, ba_io2 - ba_io1 + sz_io2] for the 2nd PCI bus. In addition, the legacy ISA devices on the second PCI bus cannot be used without modifying their drivers.
Ethernet drivers and networking
ROMFS root filesystem
Although it is the last chapter, it is probably the most necessary one. In this chapter, I will list some commonly used debugging tips and tricks.
Kernel Oops
ksymoops is a program that deciphers all the secret numbers in a kernel core dump. Old versions of
ksymoops may not work well for MIPS.
I sometimes use a script,
call2sym, written by Phil Hollenback. You just cut and past the call trace part to feed the script and it will display a possible function call stack at the time crash. Note it is likely some symbols are bogus, but the real ones should be displayed. You will have to use your own judgement.
In 2.6, the brack trace is automatically printed for you when a kernel core dump happens.
Appendix A: Linux startup sequence in 2.4.x
kernel_entry() - arch/mips/kernel/head.S set stack; prepare argc/argp/envp; jal init_arch - arch/mips/kernel/setup.c cpu_probe() - prom_init(...) - arch/mips/ddb5074/prom.c loadmmu() start_kernel() - init/main.c setup_arch(&commaind_line); - arch/mips/kernel/setup.c ddb_setup() - arch/mips/ddb5074/setup.c parse_options(command_line); trap_init(); init_IRQ(); - arch/mips/kernel/irq.c sched_init(); softirq_init(); time_init(); if (board_time_init) board_time_init(); set xtime by calling rtc_get_time(); pick appropriate do_gettimeoffset() board_timer_setup(&timer_irqaction); console_init(); init_modules(); kmem_cache_init(); sti(); /* interrupt first open */ calibrate_delay(); mem_init(); kmem_cache_sizes_init(); pgtable_cache_init(); fork_init(); proc_caches_init(); vfs_caches_init(); buffer_init(); page_cache_init(); signals_init(); smp_init(); kernel_thread(init, ...) cpu_idle(); init() - init/main.c - lock_kernel(); do_basic_setup(); - [MTRR] mtrr_init(); [SYSCTL] sysctl_init(); [S390] s390_init_machine_check(); [ACPI] acpi_init(); [PCI] pci_init(); [SBUS] sbus_init(); [PPC] ppc_init(); [MCA] mca_init(); [ARCH_ACORN] ecard_init(); [ZORRO] zorro_init(); [DIO] dio_init(); [MAC] nubus_init(); [ISAPNP] isapnp_init(); [TC] tc_init(); sock_init(); start_context_thread(); do_initcalls(); [IRDA] irda_proto_init(); [IRDA] irda_device_init(); [PCMCIA] init_pcmcia_ds(); prepare_namespace(); free_initmem(); unlock_kernel(); files = current->files; if(unshare_files()) panic("unshare"); put_files_struct(files); if (open("/dev/console", O_RDWR, 0) < 0) printk("Warning: unable to open an initial console.\n"); (void) dup(0); (void) dup(0); if (execute_command) run_init_process(execute_command); run_init_process("/sbin/init"); run_init_process("/etc/init"); run_init_process("/bin/init"); run_init_process("/bin/sh"); panic("No init found. Try passing init= option to kernel.");
Appendix B: Credits and thanks
People in the following list have generously given their feedback to me. In spite of my effort to keep the list as complete as possible, I am afraid many people are still missing here.
Dirk Behme <email@example.com> Fillod Stephane <firstname.lastname@example.com> Geoffrey Espin <firstname.lastname@example.com> Gerald Champagne <firstname.lastname@example.com> Henri Girard <firstname.lastname@example.com> Neal Crook <firstname.lastname@example.com> Steven J. Hill <firstname.lastname@example.com> TAKANO Ryousei <firstname.lastname@example.com> Motoya Kurotsu <email@example.com>


text:
Totally Brushes
by Loew Cornell
Use for crafts, hobbies, and fun activities. All-purpose brushes for use with most paints. Pack of 25 contains three chubby round; two foam size 1 in.; two nylon sizes 1/2 in. and 3/4 in.; spongit sizes 3/4 in. and 1 in.; black nylon sizes 1, 2, 3, 4, 5, 6; nylon shader size 4, 8; angular shader size 1/4 in, 3/8 in.; round size 1, 3; liner size 1; and spotter size 5/0.
Ask a question about Totally Brushes Ask a question about this product
Average User Rating: Based on (3 Reviews)
5 3
Wendy C. from Anchorage, AK says:
I prefer natural hair brushes for the smoothness on paper but these brushes are fantastic for giving me texture when I want it and for layering paint in large areas. Also, these are perfect to leave out...[more]
Please wait...
You May Also Like...
How to get VIP Club Prices
Anyone can be a VIP Member with:
Only $25/year
Your email will not be shared. We will only use your email address to respond to your question. When asking your question, please be as descriptive as possible, it will allow us to give you the most accurate answer possible.
Please wait...
Please wait...

subset: commoncrawl


text:
Perforce has integrated its Perforce Commons document collaboration platform used extensively in software application development with the Dropbox file-sharing tool.
Heavily focused on the virtues of Agile and Continuous Development, Perforce users employing Commons to store and manage the versions of their project documents can now upload files directly into Dropbox, which syncs content across all the devices associated with a customer account.
Combining the two technologies allows users to share files via Dropbox while utilizing Commons' robust collaboration and version-control capabilities.
Commons is built upon a versioning engine to extend Perforce version management to what are often less technical staff who will work with programmers in the total scheme of a given project. Documents and other files can now exist in the same shared repository that developers use for code and artists use for graphics.
This is all about giving software development projects one place for the so-called "single source of truth" for all assets — and this, so says Perforce, is a "fundamental requirement" for the emerging software development methodology of Continuous Delivery.
All Perforce products are free for up to 20 users including access to Perforce's technical support. Perforce Commons is available as both an on-premise solution and a cloud service.
"It's becoming rare for document reviews and revisions to take place exclusively at desktops connected to a server. Thanks to advanced file-sharing tools like Dropbox, users propagate their evolving documents to any number of devices and share them with their peers," said Christopher Seiwald, founder and CEO of Perforce. "That's why our integration with Dropbox is so helpful. Now our customers can easily share files across their devices while still reaping in the benefits of our enterprise version management."


text:
What is the future of farming? According to the U.S. Department of Agriculture's Census of Agriculture, the average age of a farmer in the U.S. is 58.3 years. As the agricultural community ages, the question of who will take over the next generation of farming becomes even more important. Here's what America's next generation of farmers is looking forward to, and the ways in which agriculture is drawing a new generation of Millennial farmers to the fields.
Millennial Farmers Value Independence
One of the great advantages to being a farmer is that you can be your own boss. To a generation that may be looking for life outside the cubicle, the freedom of setting your own schedule has its appeal. Farming is hard work, and most in the ag industry can tell you that there's really no such thing as a day off—but the satisfaction of building or continuing a legacy and creating something that benefits other people so much is hard to beat.
Millennials Introduce New Technology into Non-commercial Farms
Young farmers have resources previous generations didn't, thanks in part to technology. Many of the innovations we see today build upon a common practice, then put a new spin on it. In the past, you relied on other farmers for help and advice. Thanks to the internet, the next generation of farmers is connected to others in ways we've never seen before. Online forums abound, with advice on everything from marketing strategies to equipment hacks. Mobile applications have been developed to help farmers read, analyze and track climate changes, soil quality, seed requirements and more. The next generation of farmers is able to bring these easily accessible advancements to family farms. In addition, initiatives like the American Farm Bureau's Young Farmers & Ranchers Program helps to provide leadership and community for young farmers. Having the support of other farmers in similar situations can be a huge asset if you're just starting your own operation.
Ag Students are Eligible for New Financial Aid Programs and Start-up Farm Funding
According to a study conducted by the National Young Farmer's Coalition, 78 percent of farmers ranked "lack of capital" as one of their biggest obstacles to starting their own farm, and 40 percent indicated that "access to credit" is another significant roadblock. However, thanks to programs like the United States Department of Agriculture's (USDA) Beginning Farmers and Ranchers Loans, you now have access to financial aid that wasn't available to previous generations. By simply giving young farmers the means to get started, the USDA and other agencies are investing in the future of agriculture.
Millennials Want to Lead by Example in Land Stewardship Advancements
Farmers and ranchers have been caring for the land for generations. With today's new technologies and a generation of farmers that has more information than ever, conservation and stewardship of the land has become a point of pride for many of you. And programs like the Conservation Stewardship Program are encouraging farmers to maintain and improve their existing conservation systems, as well as adopting new initiatives. Goals for these programs include improving soil quality, maximizing water conservation, and protecting air quality.
All In The Family
Finally, for most of you, farming is a family business. It's more than just land or a job, and the next generation of farmers is motivated to carry on that tradition. Business succession strategies can help with the transfer of land from one generation to the next and ensure the farm stays in the family.
By Farmers, For Farmers
Farm Bureau's roots are in serving farmers, even when no one else could. We're the no. 1 insurer in our territory for a reason. If you'd like to learn more about our ag products and services, contact an agent to find out how we make insurance simple.


text:
Our on site sessions help students engage in historical enquiry working with original documents in our education suite at The National Archives in Kew.
The education suite is a pupil-friendly, welcoming, purpose-built classroom, equipped with a SMARTboard, iPads, audiovisual equipment and an induction loop.
Using documents from the collection, our enquiry-based sessions aim to deepen students' understanding of evidence and develop their skills of analysis. We accommodate group sizes of between 8-35 students, and all groups must be accompanied by at least two adults.
If you require a change in the time of the session to suit travel or timetable needs, please make a note of it on the booking form.
Please note that certain workshops can be taught at different Key Stages.
Please visit our website for more information on the delivery of sessions and to download preparation packs for use in the classroom prior to your visit.
You can contact the Education team on email@example.com if you have any questions about booking onto the workshops.
Please note that if you require a reservation for a coach bay, you can now do this online at: http://www.eventbrite.co.uk/o/the-national-archives-for-groups-9224318379
Sessions we teach:
Great Fire of London: how can we know what happened back in 1666? - This session introduces pupils to The National Archives and to some of the famous documents connected with the Great Fire of London. Pupils are introduced to primary source material as they investigate what happened in 1666 and develop their skills of historical enquiry.
London's burning! The Great Fire of London storytelling workshops: what happened in London in 1666? - An interactive storytelling session (led by professional storyteller Clive Greenwood), will introduce pupils to the events of the Great Fire and what happened on the fateful morning of 2 September 1666. Pupils will also have the opportunity to explore primary source material related to the Great Fire, as they develop their skills of historical enquiry and examine the evidence for themselves. Please contact us for more information regarding dates.
Cholera: from 'great stink' to safe to drink? What impact did the environment have on people's health in the 19th century? - This exciting workshop has been developed working with the Thames Explorer Trust, with support from the Friends of The National Archives. Children will take part in two sessions, working with original documents and on the river bank. Cost: £180 for up to 30 pupils for the Thames Explorer session.
Four days' hard labour: what was life like for a Victorian child criminal? - Photographs, reports and drawings from our prison records are used to explore the lives of Victorian children who were classed as criminals. Pupils investigate Victorian attitudes to crime and punishment, and explore the cases of children imprisoned at Wandsworth Prison in the mid-19th century.
Henry VIII: image of a king: was appearance everything for a ruler in the 16th century? - Henry VIII used symbols and images to display royal power. In this exciting session, pupils work with original documents from Henry's reign to investigate how he was portrayed as a great monarch.
Maps – a study through time: how and why does an area change over time? - This engaging session introduces pupils to some of the beautiful maps from our vast collection. From the Tudor to the Victorian period, pupils explore the ways in which London has changed over time. Pupils consider which era saw the most significant change and why; and how these different changes have marked London over time.
Propaganda and the art of war: how did the British government encourage people to support the war? - Pupils explore original propaganda posters, photographs and film to compare their effectiveness in conveying powerful messages to a mass audience.
Unmasking a spy: who was Karel Richter? - Exploring documents taken from secret Security Service files compiled during the Second World War, pupils piece together the story of German spy Karel Richter.
What is history?: How do historians know what to believe? - This exciting session gives pupils the opportunity to work with a range of primary documents selected around a specific theme. Pupils will gain an understanding of how different types of sources can be used to find out about the past, and how historians can use these sources as evidence.
Domesday Book – medieval treasure: what can we learn about people's lives in 1086? - Is the Domesday Book the most important document held here at The National Archives? In this essential workshop for beginner historians, students examine how far Domesday Book is really useful when studying medieval society. They will then judge its value against some of the greatest medieval documents in our collection. Students have the opportunity to examine some original documents from medieval England, including tally sticks, the Domesday Abbreviato and a king's wax seal. Key stages 2-3.
Domesday Book – the day of judgement: would you like to take part in our Domesday drama? - This engaging workshop brings to life one of the most important and famous documents in history! Students take part in a role-play with professional actors to find out about the history and key events behind Domesday's creation. They also have the privileged opportunity to examine original documents relating to Norman Britain, including the Domesday Abbreviato and tally sticks dating from the 13th century. This session is available for limited dates only, please contact us for more details.
Enquiring into Elizabeth: what were the issues faced by England's most famous Tudor Queen? – What was Elizabeth I's personality like? This session, run in partnership with Westminster Abbey, offers students a rare opportunity to handle original documents from the reign of Elizabeth I as well as to visit Westminster Abbey, the Coronation Church and the final resting place of Tudor monarchs. Please contact us for information regarding dates. Key stages 3-5.
Resistance and Rebellion in the Caribbean: how did enslaved people resist? - In the Caribbean, enslaved workers continually resisted their conditions. From day to day acts of resistance, such as killing livestock and pretending to be ill, to full-scale armed revolts, enslaved people confronted those that enslaved them in very different ways. In this session students will examine fascinating original documents to explore the different methods of resistance enslaved people used to resist slavery and why these were so important in their pursuit for freedom.
Britain and the Holocaust: how much did the British government know? - Students study telegrams, radio intercepts and reports received by the Foreign Office between 1942 and 1944. They learn about how the events in Nazi occupied territories unfolded and the subsequent reactions of the British government. Key stages 3-4.
Crime in Whitechapel: why was 19th century Whitechapel so hard to police? - Using original documents from our collection, students will explore the key features of Whitechapel in the 19th century to uncover why this area was such a challenge for the Metropolitan Police. Students will also discover how the police sought to overcome these challenges, from dressing as women to developing silent footwear, in their bid to rid Whitechapel of Jack the Ripper. Key stages 3-4.
Fighting conscription: why did men appeal against conscription? - In January 1916 the British Government introduced compulsory military service for all single men of military age. Why did some men decide to apply for exemption from conscription? Students answer this question by critically examining the case papers of the Middlesex Appeals Tribunal, which, between 1916 and 1918, heard the appeals of men who previously applied to a local tribunal for exemption from military service. Through the individual stories held in these records students explore the impact of conscription on British society. Key stages 3-4.
From the Front: how typical was Albert Edwin Rippington's experience of war? - '…if you ever meet a chap that says he wants to go back call him a liar'. Exploring a range of letters written by soldiers who enlisted from the Great Western Railway to fight, students will investigate these men's experiences of war; the conditions in the trenches and in reserve, and the impact that these experiences had on their morale and health of these men. Key stages 3-4.
Chartism: who were the Chartists? - This session examines Chartism through the lens of prison interviews conducted by the Home Office in 1840-1841. Using this material, students gain a fascinating insight into the lives of people participating in the early phases of the Chartist movement.
Civil rights and racial segregation: what was the response to racial segregation in the US? - Exploring a range of Foreign Office files produced by the British Government during the presidencies of Eisenhower, JFK and Johnson, students will investigate the response of the ordinary Americans and the US government to segregation within the USA.
Cold War: what was the British government anxious about during the Cold War? - Using documents from Cabinet minutes, the Prime Minister's records and Foreign Office files, this workshop focuses on British relations with the United States and the Soviet Union during the early years of the Cold War. Students also have the exciting opportunity to explore recently opened files, including those that cover the subject of espionage!
Crisis in the reign of Mary I: how far can Mary I's reign be considered a time of crisis? - In this exciting session, students work with original Tudor State Papers and consider what is meant by the term 'crisis'. How far can this notion be measured during Mary's reign? This session can be combined with a visit to Hampton Court Palace, where students take on the role of Mary's councillors and put their concerns to the Queen in person. Please note because this is a combined session with Hampton Court Palace, a fee is payable: £11 per student (minimum £187) for the afternoon session at Hampton Court Palace and available on 3 and 24 March 2017, 9 June 2017.
Dissolution of the monasteries: how far was money the motivating factor in the dissolution of the monasteries? - In this fascinating session, students will examine records produced during the reign of Henry VIII to investigate the underlying motivations behind the dissolution of the monasteries. What types of crime were the commissioners recording in their so called 'black book', and why did so many abbots submit their monasteries 'willingly' to the king?
Easter Rising – tales of the rebellion: what do the documents reveal about the Easter Rising? - Examining newspapers, proclamations and court martial files, students explore leader's intentions, public reaction and the British Government's response to the Easter Rising and its aftermath.
Elizabeth I in her own words: what can we learn about Elizabeth I's style of ruling? - Scrutinising a selection of Elizabeth's speeches and letters, students familiarise themselves with the personality of this formidable monarch and the challenges she faced. Was she true to her motto 'Semper eadum'? This session also showcases some of the beautiful images of Elizabeth throughout her reign.
Independent research: do you need help with your independent research? - This informative session gives students the opportunity to explore a selection of original documents with the guided support of an Education Officer. Sessions are available on the following themes: The Tudors, Crime and Punishment, American Civil Rights, Partition, Suffragettes and the Cold War. Students will also find out about the role of The National Archives, and how they can obtain a reader's ticket for future research.
Medicine on the Western Front: how can we find out about medical treatment in the First World War?- Using original documents, from medical cards completed in the trenches to army service records, students explore fascinating personal stories from the First World War. This workshop develops students' skills at selecting sources for particular historical enquiries. Students will investigate diverse experiences including a soldier with gas poisoning and a nurse suffering the psychological effects of working in a hospital.
Suffragettes through government eyes: 'A little daylight game'? - Exploring a range of documents taken from Home Office and Metropolitan Police files, students find out about some of the most extreme militant acts committed by suffrage campaigners in the early 20th century. How did police, government and locals respond to this militancy?
Tudor rebellions: how seriously did they challenge the authority of the crown? - Students explore original documents from the State Papers of Tudor monarchs, to consider the extent to which rebellion threatened the country 1536-1569.


text:
Worship Service
Sunday, March 17, 2019, 10:45am - 11:45am
Our Sunday morning Worship Service starts at 10:45 A.M. in the Sanctuary.
1800 W. Randol Mill Road
Arlington, TX 76012
Phone: (817) 460-8655
Email: firstname.lastname@example.com
9:30 AM Sunday School Starts
10:45 AM Worship Service Begins
12:05 PM After-Worship Fellowship
St. Stephen United Methodist Church values your gift. We use a secure, easy to use system called OnlineGiving.org to accept online donations. Gifts can be donated once or if you are looking for a continuous donation you can set up recurring donations. You can also use this system to print receipts of all donations given at the end of the year!


text:
Did you think of someone drooling in a dimly lit institution? Or someone so sedated on their seizure medicines that they aren't capable of working?
Think again.
Yes, there are some patients who still fit that description. But they're rare. You want to know what most epilepsy patients look like? They look like YOU!
Yes, folks contrary to popular belief, epilepsy patients are out there living normal lives. And there's a lot of them. It's a disorder that affects 1% of humans. So imagine the Rose Bowl stadium in California. When sold out it holds roughly 90,000 football fans. And statistically speaking 900 of them have epilepsy. Some may even be playing on the field.
Current epilepsy patients in my practice include 7 teachers, 3 doctors, 5 nurses, 1 judge, 2 veterinarians, and a lot of other responsible professionals.
Very few diseases have been as maligned over time as this one has. The majority of early cultures attributed seizures to demonic possession. I'm sure many innocent epileptics were killed in horrible fashion because of this. Others saw it as an intentional punishment from the gods. The great Dr. Charcot, founder of modern neurology, reported that in 19th century France epilepsy patients were locked up in the same dark building used to house the criminally insane and mentally handicapped.
|Detail from "Transfiguration" by Raphael (1516) showing a child possessed by demons. The boy's posture and eye deviation are typical of partial-complex epilepsy.
You don't have to look too far back in American history to find laws on the books that banned epilepsy patients from marrying or having children. In the mid-90's I even trained under a doctor who still believed that horseshit, and told young adults, just starting out in life, that they should never, ever marry or raise a family. That's a pretty damn devastating thing to do to someone.
Vilifying any person because of an illness is wrong, whether it's diabetes, hypertension, or cancer. But epilepsy is one in my specialty, and I'll make a stand for my patients.
I probably fight harder for the rights of my epilepsy patients than any other group. Several times a year I have to write a letter to a divorce attorney saying that a well-controlled seizure patient is perfectly capable of being a parent, because the ex is saying that it makes them a danger to kids. Or I have to reassure a family that a patient can drive, or work, or travel on a plane. Obviously, there are laws restricting some things, like driving, but the majority of patients follow them and are perfectly good drivers. Hell, they're likely a lot safer than many non-epileptic people behind the wheel.
So what brought on this rant?
Last week the U.S. Supreme Court upheld the Patient Protection and Affordable Care Act (AKA Obamacare). Now this post is NOT about the PPACA. I know a lot of people feel strongly about it in both directions, and if you want to fight about it, go to a website where you can. Because it's not what I'm talking about, or giving an opinion on.
What pissed me off was the reaction of a radio talk show host (who's not a medical doctor).
U.S. Chief Justice John Roberts has epilepsy and (under treatment guidelines) is likely on medication for this (I'm not his doctor). Big deal. So are a lot of other people.
But, as usual, there are some who'd rather smear than respect an opinion. Conservative commentator Michael Savage went on record last week as blaming Roberts' vote on - surprise - his epilepsy treatment (!) saying his writings showed "cognitive dissociation." He noted that drugs used for epilepsy "can introduce mental slowing, forgetfulness, and other cognitive problems."
Yes, Mr. Savage, they can cause these problems. You can also find similar side effects listed for most blood pressure medications, statins, and many other drugs (which, given your age of 70, I suspect you take at least one of) yet I'm not going to say your comments are due to medications. The side effect list of any drug is HUGE. But that doesn't mean everyone who takes it gets them. Quite the opposite.
My point is this: You're certainly entitled to your opinion. But just because you disagree with a man, don't go blaming it on his medications or health. It's a step backwards for all the epilepsy patients out there trying to lead responsible lives in the face of biases like yours. And, I suspect, if he'd ruled the other way you'd never have made such comments.
Since you apparently don't feel people being treated for seizures are capable of making rational decisions or serving in a responsible capacity, I'm leaving you with a list of people who have (or are highly suspected to have had) epilepsy. Perhaps you've heard of some.
James Madison
Napoleon Bonaparte
George Gershwin
Bud Abbott
Julius Caeser
Harriet Tubman
Vincent van Gogh
Neil Young
Lindsey Buckingham
Edward Lear
Alfred Nobel
Danny Glover
Lord Byron
Hugo Weaving
Joan of Arc
Florence Griffith Joyner
Last, I should also mention former congressman Tony Coelho, who has the disorder. He was the primary sponsor of the Americans with Disabilities Act (1990). As a young man he wanted to be a priest, but was banned from such by his epilepsy. He also lost his driver's license and health insurance because of the diagnosis.
During his first run for congress (1978, which he won) his opponent tried to paint him with the same insulting brush, asking voters how they'd feel if their representative was at a White House meeting and had a seizure. Mr. Coelho responded, "I knew a lot of people who went to the White House and had fits. At least I'd have an excuse."


text:
Calligraphy Mini Kit
by Sheaffer
This compact set is ideal for exploring the craft of fine writing with minimal investment. The kit contains one Viewpoint Calligraphy Pen with three nibs (fine, medium, and broad), four assorted Strip ink cartridges (colors vary but may include black, blue, red, green, brown, and yellow), and an informative instruction booklet. Additional ink colors and ink refills are also available.
Additional ink colors and ink refills are also available.
Ask a question about Calligraphy Mini Kit Ask a question about this product
Average User Rating: Based on (14 Reviews)
5 14
melinda c. from monticello, FL says:
I ordered a number of kits for a beginning calligraphy class, and all the students loved them and had no trouble at all getting started. A great value.
Please wait...
You May Also Like...
How to get VIP Club Prices
Anyone can be a VIP Member with:
Only $25/year
Your email will not be shared. We will only use your email address to respond to your question. When asking your question, please be as descriptive as possible, it will allow us to give you the most accurate answer possible.
Please wait...
Please wait...


text:
Linear ACT-31B ACT-21A Compatible 318 MHz Mini Key Chain Remote ACP00879 ACP00607
This great remote from Transmitter Solutions will work as a direct replacement of your Linear ACT-31B or ACT-21A and will work on any Linear Mega Code style receiver or any Linear Access Control Product. This Linear ACT-31B and ACT-21A compatible single button key chain remote is simple to program to work on your garage door opener, automatic gate opener or wireless access control device.
The unit is block coded, which means you can use this on the Linear AE100, AE500, or AE1000 systems that are programmed via modem or PC connection. The transmitter is MegaCode format, which means each transmitter is factory preprogrammed with one of over 1,000,000 codes, virtually eliminating the possibility of code duplication. Because the receiver "learns" each specific code, no unauthorized person can gain access to the system by reprogramming a transmitter.
Product Details
-Compatible with all Linear access receivers and controllers
-Includes 12V battery, key chain clip, and programming manual
-Factory programmed MegaCode format supports over 1,000,000 codes
-RF frequency: 318 MHz
-Dimensions: 2.25" x 1.25" x .5"
-Two year manufacturers warranty
- Brand: Linear
- Product Code: ACT-31
- Availability: In Stock
- Compare Price: US $19.00
Our Price: US $18.50
- 2 or more US $17.50
- 5 or more US $16.95
US Shipping - FREE
Canada Shipping - US $7.50
(Quantity shipping discount applied at checkout)


text:
UK tide times
- Recent locations
Map Menu ×
Pateley Bridge
We do not currently have any tide data for this location, please try again later.
How to use this page
To view Tide Times for a desired location, either browse the map above to select your desired location or enter a beach location into the search box and click on your chosen location. Tide tables are displayed beneath the weather forecast for up to five days ahead.
Tide times are available for around 500 locations. To change location, enter your or the first half of a UK postcode into the search box.
For web browsers that have geolocation capabilities, you can also use the 'find my location' button to automatically find your location.
What are tides?
Tides refer to the rise and fall of a body of water, most commonly seen in the oceans; caused by the interaction between the moon, sun and Earth.
As the positions of Earth, sun and moon change in relation to each other, the gravitational pull and centrifugal forces acting upon the oceans vary and it is these differences that cause fluctuation in the height of the sea which we see at the tides going out and in.
In the UK we mostly experience a semi-diurnal tide which means we experience two high tides and two low tides each day. These occur approximately every 12 hours and 25 minutes.


text:
Ideas, Formulas and Shortcuts for Book Shelving Game
If you can pick your Book Shelving Game smartly from the very start, your building efforts will be more enjoyable. Attempt not to cut corners when it regards the plans. Ultimately, you're likely to need excellent plans. Do you realize that superior design takes a very very good plan. There are several computer desk woodworking plans that enables you to select the most suitable desk that you're able to create by yourself. Excellent Desk Woodworking Plans Are Key To earn a desk that would last you a very long time, you would have to use desk woodworking plans which would steer you through the entire process.
The Plans are Difficult to Follow Even if you discover furniture plans which are actually free and appealing, you might have to be a rocket scientist to find out how to follow them. Book Shelving Game ought to have a diagram, an illustrated guide together with a step-by-step instruction which would take you from beginning to finish. It is possible to even choose computer desk woodworking plans based on your requirements, preferences and skill for a woodworker. In the majority of cases, you are able to go through hundreds or even thousands of woodworking plans and the majority of them are really nice and simple to follow along with. You can easily locate many thousands of amazing furniture plans. In fact, there are millions of door woodworking plans readily available online. Woodworking may be quite so much fun. Woodworking isn't any different. Woodworking is extremely enjoyable, and as soon as you have built one piece you will most likely want to create another. Woodworking is an incredible interest but sometimes it can be extremely frustrating. It can be a very satisfying and useful hobby. Woodworking is a skill, that may take a while to perfect the craft especially if you're attempting to work it out all on your own. You don't wish to be doing plenty of guessing when it has to do with woodworking. The woodworking plans which can be found in magazines are largely accurate and simple to follow and you will probably get fantastic effects, in the event you patiently apply each step as explained. You may also scan through some woodworking plans to find a notion of different sorts of plans. Be certain the woodworking plans you're considering are suitable for your skill level. There exist an assortment of easy woodworking plans that one might consider. Other woodworkers who have bought the woodworking program may offer you a few clues as to whether it's manageable for beginners.
Our Book Shelving Game plans incorporate detailed drawings and specifications that will allow you to finish your project efficiently. They will provide the information you need to successfully complete a project and provide a list of the materials, tools, screws, and hardware that are needed to finish the piece. All the totally free woodworking plans are in many different various styles, making it simple to find the best one for your house. A lot of spare woodworking plans can be found on the internet. 1 important item you need to consider shopping for is woodworking plans. You've got to choose plans which are perfectly clear and simple to comprehend. It's important to pick plans that are made for your individual's skill level. Therefore it's crucial to analyze yourself before you get to understand the simple plans. Easy woodworking plans are just the plans that have each detail noted along the many requirements and the elements of the undertaking. There are various woodworking plans accessible to select from.
Book Shelving Game Related Articles
Book Shelving Game Tag : Alabama, Alaska, Arizona, Arkansas, California, Colorado, Connecticut, Delaware, District of Columbia, Florida, Georgia, Hawaii, Idaho, Illinois, Indiana, Iowa, Kansas, Kentucky, Louisiana, Maine, Maryland, Massachusetts, Michigan, Minnesota, Mississippi, Missouri, Montana, Nebraska, Nevada, New Hampshire, New Jersey, New Mexico, New York, North Carolina, North Dakota, Ohio, Oklahoma, Oregon, Pennsylvania, Rhode Island, South Carolina, South Dakota, Tennessee, Texas, Utah, Vermont, Virginia, Washington, West Virginia, Wisconsin, Wyoming
Suggested Book Shelving Game articles.
- how to make a jewelry box from scratch
- diy wooden office chair
- hidden bed plans
- arbour seat garden
- adirondack chair loveseat plans
- Kitchen Breakfast Bar Drop Leaf
- Chair Design Tips
- Wooden Rustic Bench Plans Barn Wood
- Double Sided Desk With Integrated Wall Shelving
- Executive Office Desk Accessories
- Ultimate Garage Storage Australia
- Distressed Kitchen Cabinets Ideas
- quick rabbit building for indoor rabbit colony
- modern jewelry boxes for women
- how to build chairs out of pallets
- hanging loft bed plans free
- how to build a platform bed with storage drawers plans
- plum bush baby wooden single swing set
- how to make a door look like real wood
- how to build a shoe rack youtube
- acacia corner trellis with planter box
- Floor Cabinets With Glass
- Free Wood Plans For Phone Charging Station
- Linen Cabinet Hamper
- Woodcraft Designs Images
- cool wood cnc projects
- bird ground feeder
- floating arm trebuchet advantages


text:
Block Island deer herd will be thinned out by sharpshooters
It might seem quaint today how Block Islanders ferried over four does and four bucks from the mainland 45 years ago to establish a deer herd for their idyllic ocean community - if only it hadn't come to this.
Last week, town officials confronting a population that has grown wildly out of control decided they had no choice other than to hire experts to visit their island and systematically shoot deer - a first for Rhode Island.
Concerned about damage to landscaping, crops and plant ecology, as well as the spread of tick-borne diseases such as Lyme, the New Shoreham Town Council not only set aside discomfort with ordering the large-scale killing of deer but also the need for islanders to pick up the six-figure tab.
The culling could cost as much as $128,000 this winter, including $29,000 for the rendering of carcasses. But Rhode Island Department of Environmental Management officials say that the cost is likely to come in significantly lower.
Comparable amounts are likely to be needed over the next four years to progressively reduce the herd from an estimated 800 to 1,000 deer down to 100 to 150, according to Brian Tefft, a deer biologist with the state Department of Environmental Management. The goal is 10 to 15 deer per square mile on the 9.5-square-mile island.
How did eight Virginia white-tailed deer - brought to the island from 1967 to 1968 by locals presumably eager to hunt and gaze at wildlife - create such a problem?
For starters, deer can reproduce quite prolifically.
"The population can double over a very short period of time," Tefft said.
Does can have offspring every year and it's not uncommon for them to have twins, if given a chance.
On Block Island, they sure get that chance.
The island presents some unique circumstances when it comes to deer, Tefft said. For starters, there are no natural predators. Elsewhere, coyotes help control herds, preying on juveniles and birthing does. But no coyotes live on the island.
Although plenty of deer are struck by motor vehicles on the mainland, Block Island has few roads and minimal traffic.
And while hunting is allowed and is commonly relied upon to help manage populations, it has not been effective on the island.
"Block Island has a lot of private land and a lot of it is not open to hunting, so those areas become refuges for the deer," Tefft said.
New Shoreham initially sought the DEM's approval to undertake a culling using its own hunters, according to Catherine Sparks, assistant director for natural resources. But the state turned down the request out of concern for public safety and an inability to ensure that the hunters were skilled and their program effective.
"They followed up and said, 'You help us do it,'" Sparks said.
After studying the situation on the island and reviewing what other states have done to address deer nuisance problems, the DEM came up with a plan.
First, it filed emergency regulations establishing a "non-recreational" program to reduce "an imminent risk to the health, safety and welfare of Block Island's natural resources."
Then the state recommended hiring Connecticut-based White Buffalo, a company with which Tefft had become familiar at conferences for deer managers and which he tapped to help develop the Block Island plan. It is led by Anthony DeNicola, who has a doctorate in wildlife biology.
Putting the contract out to bid was deemed unwise, said Sparks.
"They have been in business for 18 years. They have experience and training in wildlife behavior. (DeNicola) has a Ph.D. He's also a sharpshooter and he hires other sharpshooters," said Sparks.
White Buffalo has been hired to cull deer herds in Princeton, N.J.; Akron, Ohio; Cayuga Heights, N.Y; and in numerous other Northeastern and Midwestern states.
"This is not recreational hunting," said Sparks. "This is a much more strategic and disciplined approach to culling a deer herd. A bidding process looks to hire the lowest bidder, which is not necessarily the best qualified all of the time. … The low bid could come from six guys in Kansas who have never done this before."
The Town Council voted 3 to 0 on Wednesday to approve the plan, reflecting what Tefft said was an estimated 70 percent of islanders favoring the plan. The number-one concern of opponents is safety, he said.
Once all the agreements have been completed, preparations will begin for White Buffalo staff to arrive in February.
Confining themselves to the lesser-developed southwestern part of the island, they will lure deer to about 15 to 20 selected sites with corn bait, Tefft said. Once the deer become habituated, sharpshooters in elevated platforms will fire at them with .223-caliber rifles, which uses slower and smaller bullets.
"You don't have that loud boom and bang," Tefft said, adding that "it's soft lead. It kills the deer instantly and humanely but doesn't pass through and hit something else."
When a group of deer arrive at the bait, the sharpshooters will strive to take down group leaders first and to not allow any deer to escape, Tefft said. That could spread fear of the location throughout the herd.
The goal for this winter is to reduce the herd by 200 animals, Tefft said.
Another out-of-state company has been recommended to deal with the carcasses. Windham Butcher Shop, of Maine, runs a mobile meat processing service that cannot be found in Rhode Island, said Sparks. The alternative would be cost-prohibitive trucking of the deer to Johnston for quartering and then to Westerly for further processing.
Windham, said Sparks, has experience with moose season up north. The mobile equipment is used to skin, bone, grind and package the meat in 10-pound packages and then to keep it refrigerated and frozen.
Islanders will have first dibs on the meat, which cannot be sold. The remainder will be offered to the Rhode Island Food Bank or other hunger programs.
Windham will charge $125 per deer, at a minimum of 200 deer, or $25,000.
Tefft said the first year is essentially a pilot project that, if proven effective, will have to be "ratcheted up island-wide" in coming years to be successful.
Long-term, however, it's not a solution.
"We will have to do a better job with our hunting program to maintain what we have," he said. "That's down the road."
As for using professional culling services elsewhere in the state to thin deer herds, Tefft said, "This is an expensive tool. It's logistically rigorous. It's not the answer everywhere. It's a unique situation."
Stories that may interest you
Trump team to brief Congress on Iran; Dems seek other views
With questions mounting over President Donald Trump's tough talk on Iran, top national security officials are heading to Capitol Hill to brief Congress
Ukraine president, a former comedian, takes political stage in dramatic fashion
Ukraine's new leader has made a dramatic beginning to his presidency by dissolving the country's parliament
Ford cuts 7,000 white-collar jobs, says it will save $600M a year, position automaker for future
Ford gets ready for a future of electric and autonomous vehicles, parting ways with 7,000 white-collar workers worldwide, about 10% of global salaried workforce
Top Senate Republican would raise minimum smoking age to 21
The Senate's top Republican is introducing legislation to raise the minimum smoking age from 18 to 21
Billionaire says he'll pay off student loans of entire college graduating class, estimated at $40M


text:
Alpha Software has announced Alpha Anywhere, its standards-based environment for rapid application development and deployment.
More Insights
White PapersMore >>
- The State of Cyber Security Incident Response
- Online Malware & Threats: A Profile of Today's Security Posture
WebcastsMore >>
Alpha Anywhere claims to be a fast way to gain proficiency and become productive in mobile and touch computing. Developers who have used Microsoft Access, Visual Basic, PowerBuilder, FoxPro, Delphi, and similar environments will feel at home with Alpha Anywhere.
CEO of Alpha Software Richard Rabins says that mobile does not exist in a vacuum and that his firm's software can be used for creating business logic and database access that incorporate other functionalities into applications such as reporting, charting, mapping, video, images, sound, scheduling, geography and geospatial functionality, and security.
Touch-enabled functionality is supported for a variety of screen sizes. Cloud extensions for deployed apps can be hosted by developer, a third-party, or in the AlphaCloud.


text:
Wolfgang Puck Stainless Steel Cookware Set - 18 pc.
Product Details
About this item
This professional quality cookware set was designed for years of culinary use. It is made of heavy gauge stainless steel for durability and features an impact bonded tri-ply base for quick even heating.
Encapsulated aluminum disc base for even heating and superior performance. Beautiful mirror polished stainless steel construction. Tempered glass lids for easy monitoring of food while cooking. Stainless steel cast handles are double riveted for added strength and durability. Strainer covers on saucepans eliminate the need for a separate colander. Interior capacity markings are laser etched in saucepans and stockpots for ease in measuring ingredients. Oven safe and great for baking. Dishwasher safe (hand wash recommended).
Policies & plans
- Stainless steel
- Tempered glass lids
- Cast hollow handles
- Encapsulated aluminum disc base
- Oven safe to 400° F
- Dishwasher safe (hand wash recommended)
- 1 qt. saucepan with pour spouts & colander cover
- 3 qt. saucepan with pour spouts & colander cover
- 12'' chef's pot with glass cover
- 8 qt. stockpot with glass cover
- 8'' omelet pan
- 10'' omelet pan
- 11'' sauté pan with glass cover
- 6 tools (solid spoon, slotted spoon, solid turner, slotted turner, fork, whisk)
Limited Lifetime
Assembled Country
Component Country
Shipping Info
Standard - 2 to 6 business days
Premium - 2 to 4 business days
Express - 1 to 2 business days


text:
Director Login
Software Support
USAR Events
Racquetball: 2018 Texas State Doubles Racquetball Championships
Date: 5/27/2019
Time: 2:48:23 AM PST
Match Report
match on by division.
New Match Report Print / Download
AP text file
R2 Sports Privacy Statement |
R2 Sports Credit Card Refund Policy
Copyright ©2010 USAR / R2Sports Racquetball Software All rights reserved.
Site by Dynamic Steps Interactive Business Solutions